Conquest

[Dr Brain]

Say what?

I started work on hyperspace conquest about 6 months ago. Conquest is the gameplay element you see in games like Battlefield 1942 and Star Wars Battlefront. I've not personally seen this in SS, but wouldn't be surprised if other zones have done it in subarenas.

 

What is conquest?

There are two teams fighting for control of various command points scattered around the map. Games I've played typically have between 4 and 8 control points on the map. The control points can be owned by either team, or unowned. Each team starts with a single control point. Players spawn at any of their team's owned control points. A control point has a ownership level ranging from 0 to 100, with 0 being unowned and 100 being fully owned. A point's ownership rating is changed by a player or players standing within a certain radius of the control point with no enemies around. A player standing near an enemy control point will slowly change it to unowned, and then slowly change it from unowned to fully owned. This process takes between 10 and 30 seconds.

 

Each team starts with a # of respawn tickets (between 200 and 1000, depending on the size of teams and desired game length). Each respawn of a player uses one of the team's ticket. Additionally, the team that controls fewer control points will lose tickets over time, proportional to how much they're behind. If a team's tickets drop to zero, they lose. There's also usually a time limit on the game (e.g. 30 minutes), and if it's exceeded the team with more tickets wins.

 

Sounds good. What's next?

I need someone to design me a conquest map. Here's the overall shape I want:

 

The #s are jump gates that correspond to each other. The Red Os are control points. A lot of liberty can be taken with this, but the idea of separate sectors should be maintained.

 

I also need LVZ images for control points (owned, enemy, & unowned), the ownership level indicators to display to nearby players (some sort of scale, including enemy, unowned and owned).

 

Then what?

An open beta, and if it goes well, the main arena will be replaced with conquest. This implies the removal of centering.

[Weebles Wobble]

So it's TW on acid but gayer. Good luck

[L.C.]

Can't view attachment because I don't have permission to view it?

 

Other than that, the idea sounds very interesting. I have not played BF1942 in a very long time, and I had very great memories playing it with my cousins.

Edited February 19, 2011 by L.C.

[Acer]

I know what you are trying to create but I'm just having a hard time picturing it happening with SS. It's a great idea and would be a lot of fun. What if a player was in a point and the enemies spot him and also go within that point would the time that it takes for it to change over stop completely in till the enemies are cleared out and continue from there or would it restart completely after the enemies are cleared?

[spidernl]

Interesting. Also, about the 'removal of centering', I don't quite agree.

Sure, there wouldn't be a 'center' in the old sense, but centering more or less translates to 'fighting in the open' where dodging and aiming are what it's about, versus other skills in basing games.

I imagine the map can also have more closed areas (similar to bases) and open space.

 

Which is good, both types of gameplay can exist that way and there'll be a use to 'centering' warbirds and such.

[L.C.]

Instead of centering, players should be specced to their freq until they (1) have a spawn point selected and (2) respawn timer expired.

[Corey]

Speaking map wise, would you like to have bases in these sectors? And how big would you like each sector to be? (including center sector) I have a lot of time on my hands and I could whip up something in a few days for testing.

[JoWie]

I have played around with a similar idea, some random ideas (they are not necessarily good):

 

• Instead of having one big game with a lot of point of contentions, divide it up in smaller sectors with 1-3 point of contentions. Each sectors is like a mini game that lasts very short. Sectors could have different match mechanics (tickets, capture all, capture 51%, flagging, etc). After 10 minutes or a win condition, the winning team is declared and owns the sector. To be able to reach a certain sector requires you to own all the sectors leading up to it.
  Winning all the sectors wins the entire game.
  The main benefit is that is concentrates the gameplay
  
• Extension to previous idea, instead of being able to win the overall game, it goes on forever. At fixed intervals rewards are given based up on the average population in the previous interval and the sectors owned. (lessens "ragequiting")
  
• Conquerable areas (sectors?) have fixed spawn locations along the edges. The ones you have access to depend on the surrounding area's you have captured (you can switch). There is no attaching or attaching has to be made more difficult
  
• Make sure a loner can not capture an area within a few seconds. Because the point of contentions take a while to capture enemies have a chance to stop him and develop a game.
  
• Different method for capturing the point of contentions: First team to hit a point of contentions starts capturing it. During the entire capture a single ship must remain within the small area of the POC. Enemy presence does not affect the capturing, when everyone on the POC dies, the capturing stops.
  This will bring more variety in ship building (dedicated tankers to sit the POCs, ships with great firepower to stop them, all rounders, rushers, etc)
  

[Dr Brain]

I've worked on this a bit today, and corey's started a map for it.

 

Here's the beginnings of a module.

 

#include "asss.h"

//modules
local Imodman *mm;
local Ichat *chat;
local Icmdman *cmdman;
local Iplayerdata *pd;
local Imapdata *mapdata;
local Igame *game;

#define CP_CHECK_INTERVAL 100

typedef struct ControlPoint
{
Region control_region;
Region spawn_region;

int ownership_level; // from 0 to max_ownership

TeamData current_team;
TeamData initial_team;
} ControlPoint;

typedef struct TeamData
{
int freq;

int current_tickets;

int control_points;
} TeamData;

typedef struct adata
{
int team_count;
TeamData *team_data;

int control_point_count;
ControlPoint *control_points;

ticks_t last_check;

ticks_t current_game_ticks; // counts down to 0 from initial_game_ticks
ticks_t initial_game_ticks;

int max_ownership;
int ownership_change_per_update;
int max_ownership_change;

int running;
int init_ok;
} adata;

typedef struct pdata
{
ControlPoint *spawn; // place where they'd like to spawn
} pdata;

local int adkey;
local int pdkey;

local pthread_mutex_t conquest_mutex = PTHREAD_MUTEX_INITIALIZER;

#define LOCK() pthread_mutex_lock(&conquest_mutex)
#define UNLOCK() pthread_mutex_unlock(&conquest_mutex)

local void start_game(Arena *arena)
{
int i;
adata *ad = P_ARENA_DATA(arena, adkey);

LOCK();

if (ad->init_ok)
{
	ad->running = TRUE;
	ad->current_game_ticks = ad->initial_game_ticks;
	ad->last_check = ad->current_game_ticks;

	// init the teams
	for (i = 0; i < ad->team_count; i++)
	{
		TeamData *td = &ad->team_data[i];
		td->current_tickets = td->initial_tickets;
		td->control_points = 0;
	}

	// init the control points
	for (i = 0; i < ad->control_point_count; i++)
	{
		ControlPoint *cp = &ad->control_points[i];

		cp->current_team = initial_team;
		if (cp->current_team)
		{
			cp->ownership_level = ad->max_ownership;
		}
		else
		{
			cp->ownership_level = 0;
		}
	}
}

UNLOCK();
}

local void end_game(Arena *arena)
{
// TODO
}

local void update_control_point(Arena *arena, ControlPoint *cp, TeamData *td, int player_count)
{
adata *ad = P_ARENA_DATA(arena, adkey);

int ownership_delta = ad->ownership_change_per_update * player_count;
if (ownership_delta > ad->max_owership_change)
{
	ownership_delta = ad->max_owership_change;
}

if (cp->current_team)
{
	if (cp->current_team == td)
	{
		// friendly team, already owned: just increase the counter
		cp->ownership_level += ownership_delta;
		if (cp->ownership_level < max_ownership)
		{
			cp->ownership_level = max_ownership;
		}
	}
	else
	{
		// enemy team
		cp->ownership_level -= ownership_delta;
		if (cp->ownership_level <= 0)
		{
			
		}
	}
}
}

local void penalize_team(Arena *arena, TeamData *td, int max_control_points)
{
int delta = max_control_points - td->control_points;

td->current_tickets -= delta;
}

local void check_control_points(Arena *arena)
{
int i;
adata *ad = P_ARENA_DATA(arena, adkey);
LinkedList control_point_players;
Player *p;
Link *link;
int max_points;
int should_end_game;

LLInit(&control_point_players);

pd->Lock();
LOCK();
if (ad->running)
{
	for (i = 0; i < ad->team_count; i++)
	{
		// clear the control point count for each team
		ad->team_data[i].control_points = 0;
	}
	
	for (i = 0; i < ad->control_point_count; i++)
	{
		int player_count;
		TeamData *td;
		ControlPoint *cp = &ad->control_points[i];
		
		// find players inside the control point's region
		// TODO: lock
		FOR_EACH_PLAYER_IN_ARENA(p, arena)
		{
			if (mapdata->Contains(cp->control_region, p->position.x >> 4, p->position.y >> 4))
			{
				LLAdd(&control_point_players, p);
			}
		}
		// TODO: unlock

		td = NULL;
		player_count = 0;
		FOR_EACH(&control_point_players, p, link)
		{
			int j;
			TeamData *player_team_data;
			
			// find the player's team data
			for (j = 0; j < ad->team_count; j++)
			{
				if (ad->team_data[j].freq == p->p_freq)
				{
					player_team_data = &ad->team_data[j];
					break;
				}
			}

			if (player_team_data)
			{
				if (!td)
				{
					// first valid team data
					td = player_team_data
				}
				else if (td != player_team_data)
				{
					// control point is in conflict
					td = NULL;
					break;
				}

				player_count++;
			}
		}
		
		if (td)
		{
			update_control_point(arena, cp, td, player_count);
		}

		// if the control point is assigned to a team, record it in the td
		if (cp->current_team)
		{
			cp->current_team->control_points++;
		}
		
		LLEmpty(&control_point_players);
	}

	// find maximum control points
	max_points = 0;
	for (i = 0; i < ad->team_count; i++)
	{
		if (arena->team_data[i].control_points > max_points)
		{
			max_points = arena->team_data[i].control_points;
		}
	}
	
	should_end_game = FALSE;
	for (i = 0; i < ad->team_count; i++)
	{
		if (arena->team_data[i].control_points < max_points)
		{
			penalize_team(arena, &arena->team_data[i], max_points);
			if (arena->team_data[i].current_tickets <= 0)
			{
				should_end_game = TRUE;
			}
		}
	}
	
	if (should_end_game)
	{
		end_game(arena);
	}
}
UNLOCK();
pd->Unlock();
}

local void check_game_timer(Arena *arena)
{
ad->current_game_ticks -= CP_CHECK_INTERVAL;
if (ad->current_game_ticks <= 0)
{
	ad->current_game_ticks = 0;
	end_game(arena);
}
}

local int check_control_points_timer(void *clos)
{
Arena *arena = (Arena*)clos;

check_control_points(arena);
check_game_timer(arena);

return TRUE;
}

local void init_arena(Arena *arena)
{
adata *ad = P_ARENA_DATA(arena, adkey);

LOCK();

LLInit(&ad->control_points);
LLInit(&ad->team_data);

ad->running = FALSE;
ad->init_ok = TRUE;

// TODO: take care of player data

UNLOCK();
}

local void free_arena(Arena *arena)
{
adata *ad = P_ARENA_DATA(arena, adkey);

LOCK();

LLEnum(&ad->control_points, afree);
LLEmpty(&ad->control_points);

LLEnum(&ad->team_data, afree);
LLEmpty(&ad->team_data);

// TODO: take care of player data

UNLOCK();
}

local void load_config(Arena *arena)
{
char buf[256];
adata *ad = P_ARENA_DATA(arena, adkey);
int i;
const char *region_name;
	
LOCK();

ad->init_ok = TRUE; // this may be recinded later

/* cfghelp: Conquest:GameTime, arena, int, def: 270000, mod: hs_conquest
 * Game duration in ticks. */
ad->initial_game_ticks = cfg->GetInt(arena->cfg, "Conquest", "GameTime", 270000);
/* cfghelp: Conquest:MaxOwnership, arena, int, def: 100, mod: hs_conquest
 * Determines the scale for ownership on 
 * control points. */
ad->max_ownership = cfg->GetInt(arena->cfg, "Conquest", "MaxOwership", 100);
/* cfghelp: Conquest:OwershipDelta, arena, int, def: 1, mod: hs_conquest
 * Determines how much ownership changes 
 * per update interval. */
ad->ownership_change_per_update = cfg->GetInt(arena->cfg, "Conquest", "OwnershipDelta", 1);
/* cfghelp: Conquest:TeamCount, arena, int, def: 2, mod: hs_conquest
 * How many frequencies play in conquest. */
ad->team_count = cfg->GetInt(arena->cfg, "Conquest", "TeamCount", 2);

if (ad->team_count < 2)
{
	ad->init_ok = FALSE;
	lm->LogA(L_ERROR, "hs_conquest", arena, "bad control point count %d", ad->control_point_count);
}

ad->team_data = amalloc(sizeof(TeamData)*ad->team_count);
for (i = 0; i < ad->team_count; i++)
{
	sprintf(buf, "Team%dFreq", i);
	ad->team_data[i].freq = cfg->GetInt(arena->cfg, "Conquest", buf, i);
}	

/* cfghelp: Conquest:ControlPointCount, arena, int, def: 0, mod: hs_conquest
 * How many frequencies play in conquest. */
ad->control_point_count = cfg->GetInt(arena->cfg, "Conquest", "ControlPointCount", 0);

if (ad->control_point_count < 1)
{
	ad->init_ok = FALSE;
	lm->LogA(L_ERROR, "hs_conquest", arena, "bad control point count %d", ad->control_point_count);
}

ad->control_points = amalloc(sizeof(ControlPoint)*ad->control_point_count);
for (i = 0; i < ad->control_point_count; i++)
{
	int initial_team;
	ControlPoint *cp = &ad->control_points[i];

	sprintf(buf, "CP%dControlRegion", i);
	region_name = cfg->GetStr(arena->cfg, "Conquest", buf);
	
	if (!region_name)
	{
		// try a default
		sprintf(buf, "cp%d", i);
		region_name = buf;
	}
	
	cp->control_region = mapdata->FindRegionByName(arena, region_name);
	if (!cp->control_region)
	{
		ad->init_ok = FALSE;
		lm->LogA(L_ERROR, "hs_conquest", arena, "could not find control region %s", region_name);
	}

	sprintf(buf, "CP%dSpawnRegion", i);
	region_name = cfg->GetStr(arena->cfg, "Conquest", buf);

	if (!region_name)
	{
		// try a default
		sprintf(buf, "cp%dspawn", i);
		region_name = buf;
	}

	cp->spawn_region = mapdata->FindRegionByName(arena, region_name);
	if (!cp->spawn_region)
	{
		ad->init_ok = FALSE;
		lm->LogA(L_ERROR, "hs_conquest", arena, "could not find spawn region %s", region_name);
	}

	sprintf(buf, "CP%dInitTeam", i);
	initial_team = cfg->GetInt(arena->cfg, "Conquest", buf, -1);
	if (initial_team > 0)
	{
		if (initial_team < ad->team_count)
		{
			cp->initial_team = &ad->team_data[initial_team];
		}
		else
		{
			ad->init_ok = FALSE;
			lm->LogA(L_ERROR, "hs_conquest", arena, "bad team %d", initial_team);
		}
	}
}

UNLOCK();
}

EXPORT const char info_hs_conquest[] = "v1.0 Dr Brain <drbrain@gmail.com>";

EXPORT int MM_hs_conquest(int action, Imodman *_mm, Arena *arena)
{
if (action == MM_LOAD)
{
	mm = _mm;

	lm = mm->GetInterface(I_LOGMAN, ALLARENAS);
	mapdata = mm->GetInterface(I_MAPDATA, ALLARENAS);
	chat = mm->GetInterface(I_CHAT, ALLARENAS);
	aman = mm->GetInterface(I_ARENAMAN, ALLARENAS);
	game = mm->GetInterface(I_GAME, ALLARENAS);
	cmdman = mm->GetInterface(I_CMDMAN, ALLARENAS);
	cfg = mm->GetInterface(I_CONFIG, ALLARENAS);
	ml = mm->GetInterface(I_MAINLOOP, ALLARENAS);
	pd = mm->GetInterface(I_PLAYERDATA, ALLARENAS);
	obj = mm->GetInterface(I_OBJECTS, ALLARENAS);

	if (!lm || !mapdata || !chat || !aman || !game || !cmdman || !cfg || !ml || !pd || !obj) return MM_FAIL;
	
	adkey = aman->AllocateArenaData(sizeof(adata));
	if (adkey == -1) return MM_FAIL;

	pdkey = pd->AllocatePlayerData(sizeof(pdata));
	if (pdkey == -1) return MM_FAIL;
	
	return MM_OK;
}
else if (action == MM_UNLOAD)
{
	aman->FreeArenaData(adkey);
	pd->FreePlayerData(pdkey);

	mm->ReleaseInterface(lm);
	mm->ReleaseInterface(mapdata);
	mm->ReleaseInterface(chat);
	mm->ReleaseInterface(aman);
	mm->ReleaseInterface(game);
	mm->ReleaseInterface(cmdman);
	mm->ReleaseInterface(cfg);
	mm->ReleaseInterface(ml);
	mm->ReleaseInterface(pd);
	mm->ReleaseInterface(obj);

	return MM_OK;
}
else if (action == MM_ATTACH)
{
	init_arena(arena);
	load_config(arena);

	// TODO: add playeraction for init players
	// todo add spawn
	
	ml->SetTimer(check_control_points_timer, CP_CHECK_INTERVAL, CP_CHECK_INTERVAL, arena, arena);
	mm->RegCallback(CB_KILL, kill_callback, arena);

	return MM_OK;
}
else if (action == MM_DETACH)
{
	ml->ClearTimer(check_control_points_timer, arena);
	mm->UnregCallback(CB_KILL, kill_callback, arena);
	
	// TODO: unreg playeraction and spawn 

	free_arena(arena);

	return MM_OK;
}
return MM_FAIL;
}

[L.C.]

I don't know if this has been mentioned yet, but I think it would be cool if Hyperspace spanned across 9 maps in a 3x3 array.. using the conquest game mode.

[Dr Brain]

I've always wanted to make each sector an arena (with shared chat and teams, of course), but never got around to programming it. There were other fun things along those lines, like dropping troops onto planets, with the space and planet battles having different "ships".

[Unix]

Would you be able to plant autoturrets to help you fortify your position once you receive 100 ownership or after reaching a certain point?

 

When I think about this, you would need a decent population to do this, early on when it's 4v4 even, I dont think it'd be very feasible to do something, at least not without the help of autoturrets helping you along the way. Also, how much running/mobility would be involved? Would there be any basing involved or would it be similar to that old turf arena? I would hope there's more action rather than more running in this kind of game play. If the sectors are spread out as they are and the ability to get to one area to the next without attaching is slow, I dont think this is very feasible at all.

 

What else would change in terms of ship settings to foster this change in pub? The spawn ticketing seems to enforce running more than anything. I dont understand the concept behind that. I'm not sure exactly how this will work though, and what other changes this would institute.

[Cheese]

if they did, i would probably have to release a beta of my fake player core to save dr brain a few hours of programming time

[spidernl]

[snippety snip]

When I think about this, you would need a decent population to do this, early on when it's 4v4

[more snipping action]

 

Well, I guess there's always an option of automatically resizing the area the game takes place in, so that as the population grows larger the available part of the map does so, too.

 

if they did, i would probably have to release a beta of my fake player core to save dr brain a few hours of programming time

 

I thought you didn't yet implement the things that hockey zone didn't yet do for its goalie?

[Cheese]

such as?

 

i scoff at the hockey goalie

[Kilo]

because you're a fool. (what did HZ not implement for line goalie--besides the being smart one..)

[Cheese]

no, you're a fool.

now go away.

[Kilo]

okay, you didn't answer my question, so I'll just assume you're writing a cheater bot.

[Cheese]

Total question marks used by Arnk: 0

 

 

 

 

 

PS:

wasnt this a thread about some kind of turf?

[Kilo]

only computer programs require perfect syntax to understand the prompt. cheater bot

[Corey]

This is what i have so far. Brain if you could take a look at these, and maybe upload them to the arena we were working on. I can't seem to get them working.

gates2.conf

Conquest_03.lvl

[Corey]

These are the spawn co-ords you requested Brain.

spawns.conf

[Cheese]

so whats going on with this lately

 

 

also, why must each node be seperate from the others?

why cant there be jump gates AND a flyable route?

[Deathmonger]

Say what?

I started work on hyperspace conquest about 6 months ago. Conquest is the gameplay element you see in games like Battlefield 1942 and Star Wars Battlefront. I've not personally seen this in SS, but wouldn't be surprised if other zones have done it in subarenas.

 

If I might make a suggestion, this is exactly the gameplay of the defunct Desert Storm zone. I don't know who ran it, but I'll bet that if you wanted to use their stuff, they would let you. That would jumpstart Conquest because all you would need are new graphics.

[spidernl]

If I might make a suggestion, this is exactly the gameplay of the defunct Desert Storm zone. I don't know who ran it, but I'll bet that if you wanted to use their stuff, they would let you. That would jumpstart Conquest because all you would need are new graphics.

 

Read my post in the other thread you mentioned this in. Desert Storm just had standard static flags to be captured turf-style, which granted points over time. It's completely incomparable to Conquest, which has a 'victory condition', captured-over-time control points, deaths coming into play, etc. Desert Storm had no modules (not even ASSS) for its style of play, so it's not like we could grab a module and have less programming work either. And the bots just allowed you to spawn at controlled flags, which I don't think will even be a part of Conquest.