Renegade/Code/Commando/gamedata.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***                            Confidential - Westwood Studios                              ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : Commando                                                     *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/Commando/gamedata.cpp                        $*
 *                                                                                             *
 *                      $Author:: Steve_t                                                     $*
 *                                                                                             *
 *                     $Modtime:: 11/01/02 4:32p                                              $*
 *                                                                                             *
 *                    $Revision:: 221                                                         $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include "gamedata.h"

#include <stdio.h>
#include <string.h>

#include "win.h"
#include "miscutil.h"
#include "cnetwork.h"
#include "chatshre.h"
#include "wwdebug.h"
#include "netinterface.h"
#include "translatedb.h"
#include "playertype.h"
#include "teammanager.h"
#include "playermanager.h"
#include "assets.h"
#include "translatedb.h"
#include "string_ids.h"
#include "gamemode.h"
#include "savegame.h"
#include "bandwidth.h"
#include "gametype.h"
#include "systimer.h"
#include "objlibrary.h"
#include "scriptzone.h"
#include "aabox.h"
#include "rendobj.h"
#include "weaponbag.h"
#include "multihud.h"
#include "wwaudio.h"
#include "textdisplay.h"
#include "render2d.h"
#include "render2dsentence.h"
#include "wwprofile.h"
#include "winevent.h"
#include "realcrc.h"
#include "useroptions.h"
#include "gdsingleplayer.h"
#include "gdcnc.h"
#include "wolgmode.h"
#include "font3d.h"
#include "nat.h"
#include "csdamageevent.h"
#include "sctextobj.h"
#include "widestring.h"
#include "vehicle.h"
#include "wolgameinfo.h"
#include "spawn.h"
#include "dlgcncwinscreen.h"
#include "dialogmgr.h"
#include "rawfile.h"
#include "consolemode.h"
#include "gamedataupdateevent.h"
#include "stylemgr.h"
#include "modpackagemgr.h"
#include "modpackage.h"
#include "bandwidthcheck.h"
#include "serversettings.h"

#include "gamespyadmin.h"
#include "specialbuilds.h"
#include "demosupport.h"
#include "specialbuilds.h"

const int cGameData::MAX_TIME_LIMIT       = 999;


cGameData *	PTheGameData = NULL;

static WideStringClass renderer_time_text;
static WideStringClass renderer_dedicated_server_label;
static WideStringClass renderer_gameplay_label;
static unsigned renderer_dedicated_server_color;
static unsigned renderer_gameplay_color;

//
// Class statics
//
const StringClass			cGameData::INI_SECTION_NAME	= "Settings";
const float					cGameData::LIMITS_X_POS			= 0.8f;
Render2DSentenceClass	*		cGameData::PTextRenderer		= NULL;
int							cGameData::HostedGameNumber	= 0;
bool							cGameData::IsManualRestart		= false;
bool							cGameData::IsManualExit			= false;
WideStringClass			cGameData::WinText;

//
// hack
//
ULONG g_ip_override = INADDR_NONE;

//------------------------------------------------------------------------------------
void cGameData::Onetime_Init(void)
{
	WWDEBUG_SAY(("cGameData::Onetime_Init\n"));
	if (!ConsoleBox.Is_Exclusive()) {
		PTextRenderer = new Render2DSentenceClass;
		StyleMgrClass::Assign_Font(PTextRenderer, StyleMgrClass::FONT_INGAME_TXT);
		PTextRenderer->Set_Mono_Spaced(true);
		PTextRenderer->Set_Clipping_Rect(Render2DClass::Get_Screen_Resolution());
	}
}

//------------------------------------------------------------------------------------
void cGameData::Onetime_Shutdown(void)
{
	WWDEBUG_SAY(("cGameData::Onetime_Shutdown\n"));

	if (!ConsoleBox.Is_Exclusive()) {
		WWASSERT(PTextRenderer != NULL);
		delete PTextRenderer;
		PTextRenderer = NULL;
	}
}

//-----------------------------------------------------------------------------
cGameData::cGameData(void)	:
	DoExeVersionsMatch (true),
	DoStringVersionsMatch (true),
	DoMapsLoop (true),
	IsMapCycleOver (false),
	MapCycleIndex(0)
{
   //WWDEBUG_SAY(("cGameData::cGameData\n"));

	IsIntermission.Set(				false);
	IsDedicated.Set(					false);
	IsAutoRestart.Set(				false);
	IsFriendlyFirePermitted.Set(	false);
	IsTeamChangingAllowed.Set(		true);
	IsPassworded.Set(					false);
	IsFreeWeapons.Set(				false);
	IsLaddered.Set(					false);
	IsClanGame.Set(					false);
	IsClientTrusted.Set(				true);
	RemixTeams.Set(					false);
	CanRepairBuildings.Set(			true);
	DriverIsAlwaysGunner.Set(		true);
	SpawnWeapons.Set(					false);

	mWinnerID							= -1;
	MaxPlayers							= 16;
	TimeLimitMinutes					= 0;
	RadarMode							= RADAR_ALL;
	IniFilename							= "";
	Motd.Format(L"");

	Set_Password(						L"");
   //Set_Owner(							"UNOWNED");
   Set_Owner(							cNetInterface::Get_Nickname());

	IntermissionTimeSeconds			= 15;
   Set_Version_Number(				cNetwork::Get_Exe_Key());
	Set_Ip_Address(0);
	Set_Port(							4848);//TSS - hardcoded port

   Set_Current_Players(0);
	IntermissionTimeRemaining		= 0;
	TimeRemainingSeconds				= 0;
	MaximumWorldDistance				= 0;
	MinQualifyingTimeMinutes		= 2;

	IsQuickMatchServer				= false;
	//ServerIsGameplayPermitted		= false;
	WinType								= WIN_TYPE_TIME;
	GameDurationS						= 0;
	LastServerConfigModTime			= 0;
	SettingsDescription = 			TRANSLATE(IDS_SERVER_SAVELOAD_CUSTOM_DEFAULT);

	Clear_Clans();

	MvpCount = 0;

#ifdef MULTIPLAYERDEMO
	MapName.Format("C&C_Under.mix");
#endif // MULTIPLAYERDEMO
}

//-----------------------------------------------------------------------------
cGameData::~cGameData(void)
{
   //WWDEBUG_SAY(("cGameData::~cGameData\n"));
}

//-----------------------------------------------------------------------------
cGameData& cGameData::operator=(const cGameData& rhs)
{
	IsIntermission						= rhs.IsIntermission;

	IsDedicated							= rhs.IsDedicated;
	IsAutoRestart						= rhs.IsAutoRestart;
	IsFriendlyFirePermitted			= rhs.IsFriendlyFirePermitted;
	IsTeamChangingAllowed			= rhs.IsTeamChangingAllowed;
	IsPassworded						= rhs.IsPassworded;
	IsFreeWeapons						= rhs.IsFreeWeapons;
	IsLaddered							= rhs.IsLaddered;
	IsClanGame							= rhs.IsClanGame;
	IsClientTrusted					= rhs.IsClientTrusted;
	RemixTeams							= rhs.RemixTeams;
	CanRepairBuildings				= rhs.CanRepairBuildings;
	DriverIsAlwaysGunner				= rhs.DriverIsAlwaysGunner;
	SpawnWeapons						= rhs.SpawnWeapons;
   Password								= rhs.Password;
	GameTitle							= rhs.GameTitle;
	Motd									= rhs.Motd;

#ifdef MULTIPLAYERDEMO
	MapName.Format("C&C_Under.mix");
#else
   MapName								= rhs.MapName;
	ModName								= rhs.ModName;
#endif

	Owner									= rhs.Owner;

   MaxPlayers							= rhs.MaxPlayers;
   TimeLimitMinutes					= rhs.TimeLimitMinutes;
	IntermissionTimeSeconds			= rhs.IntermissionTimeSeconds;
   VersionNumber						= rhs.VersionNumber;
	IpAddress							= rhs.IpAddress;
	Port									= rhs.Port;
	IniFilename							= rhs.IniFilename;
	RadarMode							= rhs.RadarMode;

	CurrentPlayers						= rhs.CurrentPlayers;
	IntermissionTimeRemaining		= rhs.IntermissionTimeRemaining;
	TimeRemainingSeconds				= rhs.TimeRemainingSeconds;
	MaximumWorldDistance				= rhs.MaximumWorldDistance;
	MinQualifyingTimeMinutes		= rhs.MinQualifyingTimeMinutes;

	for (int clanSlot = 0; clanSlot < MAX_CLAN_SLOTS; ++clanSlot) {
		mClanSlots[clanSlot] = rhs.mClanSlots[clanSlot];
	}

	return (*this);
}

//-----------------------------------------------------------------------------
void cGameData::Reset_Game(bool is_reloaded)
{
   WWDEBUG_SAY(("cGameData::Reset_Game\n"));

	//
	// Game_Reset is called on both C & S at the beginning of every game.
	//
	mWinnerID = -1;

	IsIntermission.Set(false);

	//
	// 12/11/01
	// This dialog flush was added to remove the purchase screen because it persists
	// over reload.
	//
	if (GameModeManager::Find ("Combat")->Is_Active ()) {
		if (GameModeManager::Find ("Menu")->Is_Active ()) {
			GameModeManager::Find ("Menu")->Deactivate ();
		} else {
			DialogMgrClass::Flush_Dialogs ();
		}
	}

	if (Get_Text_Display()) {
   	WWASSERT(Get_Text_Display() != NULL);
   	Get_Text_Display()->Flush();
	}

	if (!IS_MISSION) {
		WWAudioClass::Get_Instance()->Create_Instant_Sound("Game_Start", Matrix3D(1));
	}

	//TSS092601 if ( !is_reloaded ) {
	if ( !IS_MISSION || !is_reloaded ) {
		cPlayerManager::Reset_Players();
	}
	//}
   cTeamManager::Reset_Teams();

	if (Is_Time_Limit()) {
		Reset_Time_Remaining_Seconds();

		if (cNetwork::I_Am_Server()) {
			cGameDataUpdateEvent * p_event = new cGameDataUpdateEvent();
			p_event->Init(-1);
		}
   }

	if (cNetwork::I_Am_Server())
	{
		HostedGameNumber++;
	}
}

//-----------------------------------------------------------------------------
void cGameData::Swap_Team_Sides(void)
{
	//WWASSERT(Is_Team_Game());
	WWASSERT(cNetwork::I_Am_Server());

	for (
		SLNode<cPlayer> * player_node = cPlayerManager::Get_Player_Object_List()->Head();
		player_node;
		player_node = player_node->Next()) {

		cPlayer * p_player = player_node->Data();
		WWASSERT(p_player != NULL);

		int team = p_player->Get_Player_Type();

		WWASSERT(team == PLAYERTYPE_NOD || team == PLAYERTYPE_GDI);

		int new_team = PLAYERTYPE_NOD;
		if (team == PLAYERTYPE_NOD)
		{
			new_team = PLAYERTYPE_GDI;
		}
		else
		{
			new_team = PLAYERTYPE_NOD;
		}

		p_player->Set_Player_Type(new_team);
	}

	//
	// Inform the players
	//
	//WideStringClass text;
	//text.Format(L"_TEAMS_SWAPPED_!_");
	WideStringClass text = TRANSLATE(IDS_MP_TEAMS_SWAPPED);
	cScTextObj * p_text_obj = new cScTextObj();
	p_text_obj->Init(text, TEXT_MESSAGE_PUBLIC, false, HOST_TEXT_SENDER, -1);
}

//-----------------------------------------------------------------------------
void cGameData::Remix_Team_Sides(void)
{
	//WWASSERT(Is_Team_Game());
	WWASSERT(cNetwork::I_Am_Server());

	WWASSERT(IsClanGame.Is_False() && "Remix teams not allowed");

	if (IsClanGame.Is_True()) {
		return;
	}

	//
	// Randomly choose a team for each player
	//
	for (
		SLNode<cPlayer> * player_node = cPlayerManager::Get_Player_Object_List()->Head();
		player_node;
		player_node = player_node->Next()) {

		cPlayer * p_player = player_node->Data();
		WWASSERT(p_player != NULL);

		int new_team = PLAYERTYPE_NOD;
		if (rand() % 2 == 0)
		{
			new_team = PLAYERTYPE_GDI;
		}
		else
		{
			new_team = PLAYERTYPE_NOD;
		}

		p_player->Set_Player_Type(new_team);
	}

	//
	// Inform the players
	//
	//WideStringClass text;
	//text.Format(L"_TEAMS_REMIXED_!_");
	WideStringClass text = TRANSLATE(IDS_MP_TEAMS_REMIXED);
	cScTextObj * p_text_obj = new cScTextObj();
	p_text_obj->Init(text, TEXT_MESSAGE_PUBLIC, false, HOST_TEXT_SENDER, -1);
}

//-----------------------------------------------------------------------------
void cGameData::Rebalance_Team_Sides(void)
{
	//WWASSERT(Is_Team_Game());
	WWASSERT(cNetwork::I_Am_Server());

	WWASSERT(IsClanGame.Is_False() && "Rebalance teams not allowed");

	if (IsClanGame.Is_True()) {
		return;
	}

	//
	// Rebalance teams numerically
	//
	cTeam * p_nod = cTeamManager::Find_Team(PLAYERTYPE_NOD);
	WWASSERT(p_nod != NULL);

	cTeam * p_gdi = cTeamManager::Find_Team(PLAYERTYPE_GDI);
	WWASSERT(p_gdi != NULL);

	int move_count = 0;

	int nod_tally = 0;
	int gdi_tally = 0;

	do
	{
		nod_tally = p_nod->Tally_Size();
		gdi_tally = p_gdi->Tally_Size();

		if (nod_tally > gdi_tally + 1)
		{
			cPlayer * p_player = cPlayerManager::Find_Team_Player(PLAYERTYPE_NOD);
			WWASSERT(p_player != NULL);
			p_player->Set_Player_Type(PLAYERTYPE_GDI);
			move_count++;
		}
		else if (gdi_tally > nod_tally + 1)
		{
			cPlayer * p_player = cPlayerManager::Find_Team_Player(PLAYERTYPE_GDI);
			WWASSERT(p_player != NULL);
			p_player->Set_Player_Type(PLAYERTYPE_NOD);
			move_count++;
		}

	} while (::abs(nod_tally - gdi_tally) > 1);

	if (move_count > 0) {
		//
		// Inform the players
		//
		//WideStringClass text;
		//text.Format(L"_TEAMS_REBALANCED_!_");
		WideStringClass text = TRANSLATE(IDS_MP_TEAMS_REBALANCED);
		cScTextObj * p_text_obj = new cScTextObj();
		p_text_obj->Init(text, TEXT_MESSAGE_PUBLIC, false, HOST_TEXT_SENDER, -1);
	}
}

//-----------------------------------------------------------------------------
void cGameData::Set_Ip_And_Port(void)
{
	/*
	SOCKADDR_IN local_address;
   bool retcode = cNetUtil::Get_Local_Address(&local_address);
	WWASSERT(retcode == true);

	//
	// hack
	//
	if (g_ip_override != INADDR_NONE) {
		local_address.sin_addr.s_addr = g_ip_override;
	}

	Set_Ip_Address(local_address.sin_addr.s_addr);
	*/

	ULONG ip = 0;
	if (cGameSpyAdmin::Get_Is_Server_Gamespy_Listed()) {
		ip = cUserOptions::PreferredGameSpyNic.Get();
	} else {
		ip = cUserOptions::PreferredLanNic.Get();
	}

	if (g_ip_override != INADDR_NONE) {
		ip = g_ip_override;
	}

	//
	// IP is set automatically in WOL unless there is an IP override and a port overrride.
	//
	if (GameModeManager::Find("WOL")->Is_Active()) {

		if (g_ip_override == INADDR_NONE || WOLNATInterface.Get_Force_Port() == 0) {
			unsigned long temp = FirewallHelper.Get_Local_Address();
			if (temp) {
				//ip = temp;
				ip = ::ntohl(temp);
			}
		}
	}

	//WWASSERT(ip != 0);
	Set_Ip_Address(ip);
}

//-----------------------------------------------------------------------------
//
// A convenience function...
//
bool cGameData::Set_Generic_Num(int generic_num,
   int lower_bound, int upper_bound, int & set_num)
{
   if (generic_num >= lower_bound && generic_num <= upper_bound) {
      set_num = generic_num;
      return true;
   } else {
      return false;
   }
}

//-----------------------------------------------------------------------------
bool cGameData::Set_Max_Players(int max)
{
   return Set_Generic_Num(max, 0, MAX_PLAYERS, MaxPlayers);
}

//-----------------------------------------------------------------------------
bool cGameData::Set_Time_Limit_Minutes(int time_limit_minutes)
{
   return Set_Generic_Num(time_limit_minutes, 0, MAX_TIME_LIMIT, TimeLimitMinutes);
}

//-----------------------------------------------------------------------------
void cGameData::Set_Radar_Mode(RadarModeEnum mode)
{
   RadarMode = mode;
}

//-----------------------------------------------------------------------------
void cGameData::Set_Intermission_Time_Seconds(int time)
{
	WWASSERT(time >= 0);
	IntermissionTimeSeconds = time;
}

//-----------------------------------------------------------------------------
void cGameData::Set_Motd(const WCHAR * motd)
{
	WWASSERT(motd != NULL);

	Motd = motd;
}


//-----------------------------------------------------------------------------
void cGameData::Set_Mod_Name(const StringClass &mod_name)
{
	ModName = mod_name;
	ModPackageMgrClass::Set_Current_Package (ModName);
	return ;
}

//-----------------------------------------------------------------------------
void cGameData::Set_Map_Name(const StringClass & map_name)
{
#ifdef MULTIPLAYERDEMO
	MapName.Format("C&C_Under.mix");
#else
	MapName = map_name;
#endif
}

//-----------------------------------------------------------------------------
bool cGameData::Set_Current_Players(int current)
{
   return Set_Generic_Num(current, 0, MAX_PLAYERS, CurrentPlayers);
}

//-----------------------------------------------------------------------------
void cGameData::Set_Owner(WideStringClass & owner)
{
   Owner = owner;
}

//-----------------------------------------------------------------------------
void cGameData::Set_Ip_Address(ULONG ip_address)
{
	IpAddress = ip_address;
}

//-----------------------------------------------------------------------------
void cGameData::Set_Port(int port)
{
   WWASSERT(port >= MIN_SERVER_PORT && port <= MAX_SERVER_PORT);
	Port = port;
}

//-----------------------------------------------------------------------------
bool cGameData::Is_Limited(void) const
{
	return Is_Time_Limit();
}

//-----------------------------------------------------------------------------
bool cGameData::Is_Map_Valid(char **out_filename)
{
	bool map_exists = false;
	if (ModName.Is_Empty () == false) {
		if (out_filename) {
			*out_filename = ModName.Peek_Buffer();
		}
		map_exists = cMiscUtil::File_Exists (ModName);
	} else {
		if (out_filename) {
			*out_filename = MapName.Peek_Buffer();
		}
		map_exists = cMiscUtil::File_Exists (MapName);
	}

	return(map_exists);
}


#define PRINT_CONFIG_ERROR	ConsoleBox.Print("File %s - Error:\r\n\t ", Get_Ini_Filename());

//-----------------------------------------------------------------------------
bool cGameData::Is_Valid_Settings(WideStringClass& outMsg, bool check_as_server)
{
	if (MapName.Is_Empty()) {
		//cHelpText::Set(TRANSLATION(IDS_MP_NO_LEVEL_SELECTED));
		Debug_Say(( "cGameData::No level file selected.\n" ));
		PRINT_CONFIG_ERROR;
		ConsoleBox.Print("No initial level file selected\n\n");
		outMsg = TRANSLATE(IDS_HOPTERR_NO_LEVEL);
		return false;
	} else {

		//
		//	Test to see whether or not the map exists
		//
		char *filename = NULL;
		if (!Is_Map_Valid(&filename)) {
			Debug_Say(("cGameData::Is_Valid_Settings: Level \"%s\" not found\n", filename));
			PRINT_CONFIG_ERROR;
			ConsoleBox.Print("Map file '%s' not found\n\n", filename);
			outMsg.Format(TRANSLATE(IDS_HOPTERR_MAP_NOTFOUND), filename);
			return(false);
		}
	}

	if (IsPassworded.Is_True() && Password.Get_Length () == 0) {
		//cHelpText::Set(TRANSLATION(IDS_MP_BLANK_PASSWORD_ILLEGAL));
		Debug_Say(( "cGameData::Is_Valid_Settings: You can not use a blank password.\n" ));
		PRINT_CONFIG_ERROR;
		ConsoleBox.Print("Blank passwords are not allowed\n\n");
		outMsg = TRANSLATE(IDS_HOPTERR_BLANK_PASS);
		return false;
	}

#ifndef FREEDEDICATEDSERVER
	if (GameModeManager::Find("WOL")->Is_Active()) {
#endif //FREEDEDICATEDSERVER
		if (IsPassworded.Is_True() && Is_QuickMatch_Server()) {
			Debug_Say(("cGameData::Is_Valid_Settings: Quickmatch can not have passwords.\n" ));
			PRINT_CONFIG_ERROR;
			ConsoleBox.Print("A password cannot be used on a Quickmatch server\n\n");
			outMsg = TRANSLATE(IDS_HOPTERR_QM_HASPASS);
			return false;
		}

		if (Is_QuickMatch_Server() && IsLaddered.Is_False()) {
			Debug_Say(("cGameData::Is_Valid_Settings: Quickmatch must be laddered.\n" ));
			PRINT_CONFIG_ERROR;
			ConsoleBox.Print("A Quickmatch server must also be laddered\n\n");
			outMsg = TRANSLATE(IDS_HOPTERR_QM_NOLADDER);
			return false;
		}

		if (Is_QuickMatch_Server() && IsClanGame.Is_True()) {
			Debug_Say(("cGameData::Is_Valid_Settings: Quickmatch cannot be clanned.\n" ));
			PRINT_CONFIG_ERROR;
			ConsoleBox.Print("Clans are not allowed in a quickmatch server\n\n");
			outMsg = TRANSLATE(IDS_HOPTERR_QM_NOCLANS);
			return false;
		}

		if (IsLaddered.Is_True() && IsTeamChangingAllowed.Is_True()) {
			PRINT_CONFIG_ERROR;
			ConsoleBox.Print("Team changing not allowed on a laddered server\n\n");
			outMsg = TRANSLATE(IDS_HOPTERR_NO_TEAMCHANGE);
			return false;
		}

		if (IsClanGame.Is_True() && (IsTeamChangingAllowed.Is_True() || RemixTeams.Is_True())) {
			PRINT_CONFIG_ERROR;
			ConsoleBox.Print("Team changing or Team Remix not allowed on a clan game server.\n");
			outMsg = "Team changing or Team Remix not allowed on a clan game server."; //TRANSLATE(IDS_HOPTERR_NO_TEAMCHANGE);
			return false;
		}
#ifndef FREEDEDICATEDSERVER
	}
#endif //FREEDEDICATEDSERVER

#ifdef FREEDEDICATEDSERVER
	if (Get_Max_Players() == 0 && ServerSettingsClass::Get_Game_Mode() !=
		ServerSettingsClass::MODE_WOL) {
#else
	if (Get_Max_Players() == 0) {
#endif
		PRINT_CONFIG_ERROR;
		ConsoleBox.Print("Max player count must be greater than 0\n\n");
		outMsg = TRANSLATE(IDS_HOPTERR_MAXPLAYER_0);
		return(false);
	}

	// Check server only parameters
	if (check_as_server || ConsoleBox.Is_Exclusive()) {
		if (Get_Max_Players() > NetworkObjectClass::MAX_CLIENT_COUNT-1) {
			PRINT_CONFIG_ERROR;
			ConsoleBox.Print("Max player count must be less than %d\n\n", NetworkObjectClass::MAX_CLIENT_COUNT);
			outMsg.Format(TRANSLATE(IDS_HOPTERR_MAXPLAYER_TOOBIG), NetworkObjectClass::MAX_CLIENT_COUNT);
			return(false);
		}

		if (DoMapsLoop && Get_Map_Cycle(0).Get_Length() == 0) {
			PRINT_CONFIG_ERROR;
			ConsoleBox.Print("Map cycling is enabled but there are no maps in the cycle\n\n");
			outMsg = TRANSLATE(IDS_HOPTERR_NO_MAPCYCLE);
			return(false);
		}

		/*
		** Make sure all the maps exist.
		*/
		if (DoMapsLoop && ModName.Is_Empty ()) {
			for (int i=0 ; i<MAX_MAPS ; i++) {
				StringClass map_name = Get_Map_Cycle(i);
				if (map_name.Get_Length()) {
					char filename[_MAX_PATH];
					sprintf(filename, "data\\%s", map_name.Peek_Buffer());
					RawFileClass file(filename);
					if (!file.Is_Available()) {
						PRINT_CONFIG_ERROR;
						ConsoleBox.Print("Map file '%s' not found\n\n", filename);
						outMsg.Format(TRANSLATE(IDS_HOPTERR_MAP_NOTFOUND), filename);
						return(false);
					}
				}
			}
		}

		/*
		** Check the game end conditions.
		*/
		if (!Is_Limited()) {
			//cHelpText::Set(TRANSLATION(IDS_MP_GAMEMODE_NEEDS_LIMIT));
			PRINT_CONFIG_ERROR;
			ConsoleBox.Print("Game must end by time limit or base destruction\n\n");
			outMsg = TRANSLATE(IDS_HOPTERR_NO_GAMEEND);
			return false;
		}

		/*
		** Check the Message of the day for excessive length.
		*/
		if (Motd.Get_Length() > MAX_MOTD_LENGTH) {
			PRINT_CONFIG_ERROR;
			ConsoleBox.Print("Message of the day cannot exceed %d characters\n\n", MAX_MOTD_LENGTH);
			outMsg.Format(TRANSLATE(IDS_HOPTERR_MOTD_TOOBIG), MAX_MOTD_LENGTH);
			return false;
		}

		/*
		** Check the game title for length. The buffers are pretty much all 256 bytes but 100 seems a more reasonable figure.
		*/
		if (GameTitle.Get_Length() > 100) {
			PRINT_CONFIG_ERROR;
			ConsoleBox.Print("Game title cannot exceed %d characters\n\n", 100);
			outMsg.Format(TRANSLATE(IDS_HOPTERR_TITLE_TOOBIG), 100);
			return false;
		}
	}

	return true; // it's valid !
}


//-----------------------------------------------------------------------------
//
// Server options are exported in 2 tiers. Tier 1 is the basic parameters
// that show up in the list of games. Tier 2 is the remainder of the full
// set of server settings.
//
void cGameData::Export_Tier_1_Data(cPacket & packet)
{
	packet.Add(IpAddress);
	packet.Add_Wide_Terminated_String(Owner);
	packet.Add_Wide_Terminated_String(GameTitle, true);

	packet.Add(Port);
	packet.Add(CurrentPlayers);
   packet.Add(MaxPlayers);
	packet.Add(VersionNumber);

	//
	//	Send the individual CRC's (for internal use)
	//
	packet.Add(cNetwork::Get_Exe_CRC ());
	packet.Add(cNetwork::Get_Strings_CRC ());

	packet.Add(IsDedicated.Get());
	packet.Add(IsTeamChangingAllowed.Get());
	packet.Add(IsPassworded.Get());
	packet.Add(IsLaddered.Get());
	packet.Add(IsClanGame.Get());

#ifndef MULTIPLAYERDEMO
	packet.Add(::CRC_Stringi(MapName));
	packet.Add(::CRC_Stringi(ModName));
#endif // MULTIPLAYERDEMO
}

//-----------------------------------------------------------------------------
void cGameData::Import_Tier_1_Data(cPacket & packet)
{
	ULONG ip_address = packet.Get(ip_address);
   Set_Ip_Address(ip_address);

	WideStringClass owner;
	packet.Get_Wide_Terminated_String(owner.Get_Buffer(256), 256);
   Set_Owner(owner);

	WideStringClass title;
	packet.Get_Wide_Terminated_String(title.Get_Buffer(256), 256, true);
   Set_Game_Title(title);

	int	i_placeholder;
	bool	b_placeholder;

   Set_Port(						packet.Get(i_placeholder));
   Set_Current_Players(			packet.Get(i_placeholder));
   Set_Max_Players(				packet.Get(i_placeholder));
   Set_Version_Number(			packet.Get(i_placeholder));

	//
	//	Compare the individual CRC's against our own
	//
	DoExeVersionsMatch		= (packet.Get(i_placeholder) == cNetwork::Get_Exe_CRC ());
	DoStringVersionsMatch	= (packet.Get(i_placeholder) == cNetwork::Get_Strings_CRC ());

	IsDedicated.Set(				packet.Get(b_placeholder));
	IsTeamChangingAllowed.Set(	packet.Get(b_placeholder));
	IsPassworded.Set(				packet.Get(b_placeholder));
	IsLaddered.Set(				packet.Get(b_placeholder));
	IsClanGame.Set(				packet.Get(b_placeholder));

#ifndef MULTIPLAYERDEMO
	//
	//	Get the CRC of the map and the mod
	//
	ULONG map_name_crc =		packet.Get(map_name_crc);
	ULONG mod_name_crc =		packet.Get(mod_name_crc);


	//
	//	Determine what the name of the mod and the map are from their CRC's
	//
	StringClass mod_name(0,true);
	StringClass map_name(0,true);
	if (ModPackageMgrClass::Get_Mod_Map_Name_From_CRC (mod_name_crc, map_name_crc, &mod_name, &map_name)) {
		Set_Mod_Name (mod_name);
		Set_Map_Name (map_name);
	} else {
		ModName = L"";
		MapName = L"";
	}

#endif // MULTIPLAYERDEMO

	return ;
}


//-----------------------------------------------------------------------------
bool cGameData::Does_Map_Exist (void)
{
	bool retval = true;

	//
	//	If the map and mod names are empty then it is due to the fact
	// that we couldn't find the map and/or mod when we looked
	//
	if (ModName.Is_Empty () && MapName.Is_Empty ()) {
		retval = false;
	}

	return retval;
}


//-----------------------------------------------------------------------------
void cGameData::Import_Tier_1_Data(const WOLGameInfo& gameInfo)
{
	Set_Map_Name(gameInfo.MapName());
	Set_Mod_Name(gameInfo.ModName());

	WideStringClass title(0, true);
	title.Convert_From(gameInfo.Title());
	Set_Game_Title(title);

	Set_Max_Players(gameInfo.MaxPlayers());
	Set_Current_Players(gameInfo.NumPlayers());

	// Set game flags
	IsDedicated.Set(gameInfo.IsDedicated());
	IsPassworded.Set(gameInfo.IsPassworded());
	IsLaddered.Set(gameInfo.IsLaddered());
	IsFriendlyFirePermitted.Set(gameInfo.IsFriendlyFire());
	IsFreeWeapons.Set(gameInfo.IsFreeWeapons());
	RemixTeams.Set(gameInfo.IsTeamRemix());
	IsTeamChangingAllowed.Set(gameInfo.IsTeamChange());
	IsClanGame.Set(gameInfo.IsClanGame());
	IsQuickMatchServer = gameInfo.IsQuickmatch();

	CanRepairBuildings.Set(gameInfo.IsRepairBuildings());
	DriverIsAlwaysGunner.Set(gameInfo.IsDriverGunner());
	SpawnWeapons.Set(gameInfo.IsSpawnWeapons());

	Clear_Clans();
	mClanSlots[0] = gameInfo.ClanID1();
	mClanSlots[1] = gameInfo.ClanID2();
}


//-----------------------------------------------------------------------------
void cGameData::Export_Tier_2_Data(cPacket & packet)
{
   packet.Add(TimeLimitMinutes);
   packet.Add((int) RadarMode);
   packet.Add(IntermissionTimeSeconds);
   packet.Add(MinQualifyingTimeMinutes);

	packet.Add(IsFriendlyFirePermitted.Get());
	packet.Add(IsFreeWeapons.Get());
	packet.Add(IsClientTrusted.Get());
	packet.Add(RemixTeams.Get());

	if (Is_Cnc()) {
		packet.Add(CanRepairBuildings.Get());
		packet.Add(DriverIsAlwaysGunner.Get());
		packet.Add(SpawnWeapons.Get());
	}

	packet.Add_Wide_Terminated_String(Motd, true);
}

//-----------------------------------------------------------------------------
void cGameData::Import_Tier_2_Data(cPacket & packet)
{
   int	i_placeholder = 0;
   bool	b_placeholder = false;

   Set_Time_Limit_Minutes(						packet.Get(i_placeholder));
   Set_Radar_Mode((RadarModeEnum)			packet.Get(i_placeholder));
   Set_Intermission_Time_Seconds(			packet.Get(i_placeholder));
   Set_Min_Qualifying_Time_Minutes(			packet.Get(i_placeholder));

	IsFriendlyFirePermitted.Set(				packet.Get(b_placeholder));
	IsFreeWeapons.Set(							packet.Get(b_placeholder));
	IsClientTrusted.Set(							packet.Get(b_placeholder));
	RemixTeams.Set(								packet.Get(b_placeholder));

	if (Is_Cnc()) {
		CanRepairBuildings.Set(					packet.Get(b_placeholder));
		DriverIsAlwaysGunner.Set(				packet.Get(b_placeholder));
		SpawnWeapons.Set(							packet.Get(b_placeholder));
	}

	WideStringClass motd;
	packet.Get_Wide_Terminated_String(motd.Get_Buffer(MAX_MOTD_LENGTH), MAX_MOTD_LENGTH, true);
	Set_Motd(motd);
}

//-----------------------------------------------------------------------------
void cGameData::Load_From_Server_Config(LPCSTR config_file)
{
	WWASSERT(config_file != NULL);
   WWASSERT(cMiscUtil::Is_String_Different(config_file, ""));

   INIClass * p_ini = Get_INI(config_file);
	StringClass full_filename(config_file, true);

	if (p_ini == NULL) {
      full_filename.Format("data\\%s", config_file);
      FILE * file = fopen(full_filename, "w");
	   fclose(file);

		p_ini = Get_INI(config_file);
   }
	WWASSERT(p_ini != NULL);

	LastServerConfigModTime = Get_Config_File_Mod_Time();

	char		map_name[MAX_MAPNAME_SIZE];
	char		mod_name[MAX_MAPNAME_SIZE];
	char		string8[256];
   bool		b;
   int		i;
   //float		f;


	//p_ini->Get_String(	INI_SECTION_NAME, "Password", Get_Password(), password, sizeof(password));
	//Set_Password(password);

   p_ini->Get_String(	INI_SECTION_NAME, "MapName", "", map_name, sizeof(map_name));
	StringClass map(map_name,true);
   Set_Map_Name(map);

   p_ini->Get_String(	INI_SECTION_NAME, "ModName", "", mod_name, sizeof(mod_name));
	StringClass mod(mod_name,true);
   Set_Mod_Name(mod);

	i = p_ini->Get_Int(	INI_SECTION_NAME, "TimeLimitMinutes",			Get_Time_Limit_Minutes());
	Set_Time_Limit_Minutes(i);

   i = p_ini->Get_Int(	INI_SECTION_NAME, "RadarMode",					Get_Radar_Mode());
	Set_Radar_Mode((RadarModeEnum) i);

   //i = p_ini->Get_Int(	INI_SECTION_NAME, "IntermissionTimeSeconds",	Get_Intermission_Time_Seconds());
	//Set_Intermission_Time_Seconds(i);
#ifndef FREEDEDICATEDSERVER
	i = p_ini->Get_Int(	INI_SECTION_NAME, "Port",							Get_Port());
	Set_Port(i);

	b = p_ini->Get_Bool(	INI_SECTION_NAME, "IsDedicated",					IsDedicated.Get());
	IsDedicated.Set(b);
#else ////FREEDEDICATEDSERVER
	IsDedicated.Set(true);
#endif //FREEDEDICATEDSERVER

	b = p_ini->Get_Bool(	INI_SECTION_NAME, "IsAutoRestart",				IsAutoRestart.Get());
	IsAutoRestart.Set(b);

	b = p_ini->Get_Bool(	INI_SECTION_NAME, "IsPassworded",				IsPassworded.Get());
	IsPassworded.Set(b);

	b = p_ini->Get_Bool(	INI_SECTION_NAME, "IsQuickMatch",				IsQuickMatchServer.Get());
	IsQuickMatchServer.Set(b);

	b = p_ini->Get_Bool(	INI_SECTION_NAME, "IsLaddered",					IsLaddered.Get());
#ifndef FREEDEDICATEDSERVER
	b = ((IsQuickMatchServer.Get() == true) ? true : b);
#endif //FREEDEDICATEDSERVER
	IsLaddered.Set(b);

	b = p_ini->Get_Bool(	INI_SECTION_NAME, "IsClanGame",					IsClanGame.Get());
#ifndef FREEDEDICATEDSERVER
	b = ((IsQuickMatchServer.Get() == true) ? false : b);
#endif /FREEDEDICATEDSERVER
	IsClanGame.Set(b);

	b = p_ini->Get_Bool(	INI_SECTION_NAME, "RemixTeams",					RemixTeams.Get());
	RemixTeams.Set(b);

	b = p_ini->Get_Bool(	INI_SECTION_NAME, "CanRepairBuildings",		CanRepairBuildings.Get());
	CanRepairBuildings.Set(b);

	b = p_ini->Get_Bool(	INI_SECTION_NAME, "DriverIsAlwaysGunner",		DriverIsAlwaysGunner.Get());
	DriverIsAlwaysGunner.Set(b);

	b = p_ini->Get_Bool(	INI_SECTION_NAME, "SpawnWeapons",				SpawnWeapons.Get());
	SpawnWeapons.Set(b);

	//
	// Disguise "IsClientTrusted" with something that sounds like you need it but
	// that doesn't scream "hack me"
	//
	//b = p_ini->Get_Bool(	INI_SECTION_NAME, "IsClientTrusted",			IsClientTrusted.Get());
	b = p_ini->Get_Bool(	INI_SECTION_NAME, "UseLagReduction",			IsClientTrusted.Get());
	IsClientTrusted.Set(b);

	// Read the 8 bit versions of the strings first and use those as defaults.
   p_ini->Get_String(INI_SECTION_NAME, "bGameTitle", "", string8, sizeof(string8));
	Set_Game_Title(WideStringClass(string8, true));

   p_ini->Get_String(INI_SECTION_NAME, "bMotd", "", string8, sizeof(string8));
	Set_Motd(WideStringClass(string8, true));

   p_ini->Get_String(INI_SECTION_NAME, "bPassword", "", string8, sizeof(string8));
	Set_Password(WideStringClass(string8, true));

	p_ini->Get_String(INI_SECTION_NAME, "bConfigName", "", string8, sizeof(string8));
	Set_Settings_Description(WideStringClass(string8, true));

	// Now read the 16 bit versions as overrides.
	WideStringClass wide_string(Get_Game_Title(), true);
	p_ini->Get_Wide_String(wide_string, INI_SECTION_NAME, "wGameTitle", wide_string.Peek_Buffer());
	Set_Game_Title(wide_string);

	wide_string = Get_Password();
	p_ini->Get_Wide_String(wide_string, INI_SECTION_NAME, "wPassword", wide_string.Peek_Buffer());
	Set_Password(wide_string);

	wide_string = Get_Motd();
	p_ini->Get_Wide_String(wide_string, INI_SECTION_NAME, "wMotd", wide_string.Peek_Buffer());
	Set_Motd(wide_string);

	wide_string = Get_Settings_Description();
	p_ini->Get_Wide_String(wide_string, INI_SECTION_NAME, "wConfigName", wide_string.Peek_Buffer());
	Set_Settings_Description(wide_string);

	for (int j = 0; j < MAX_MAPS; j++) {
		StringClass item_name(0,true);
		item_name.Format("MapName%02d", j);
		p_ini->Get_String(	INI_SECTION_NAME, item_name, "", map_name, sizeof(map_name));
		StringClass map(map_name,true);
		MapCycle[j] = map;
	}

	//char motd[2 * MAX_MOTD_LENGTH];
	//p_ini->Get_String(	INI_SECTION_NAME, "Motd", "", motd, sizeof(motd));
	//if (::strlen(motd) > 0) {
	//	Motd.Convert_From(motd);
	//}

   Release_INI(p_ini);
}

//-----------------------------------------------------------------------------
void cGameData::Save_To_Server_Config(LPCSTR config_file)
{
	WWASSERT(config_file != NULL);
   WWASSERT(cMiscUtil::Is_String_Different(config_file, ""));

   INIClass * p_ini = Get_INI(config_file);
   WWASSERT(p_ini != NULL);


	//
	// We can't overwrite entries, so clear them out first.
	//
	p_ini->Clear(INI_SECTION_NAME);
	p_ini->Put_Wide_String(	INI_SECTION_NAME, "wConfigName",					Get_Settings_Description());
   p_ini->Put_Wide_String(	INI_SECTION_NAME, "wPassword",					Get_Password());
	p_ini->Put_String(		INI_SECTION_NAME, "MapName",						Get_Map_Name());
	p_ini->Put_String(		INI_SECTION_NAME, "ModName",						Get_Mod_Name());
   p_ini->Put_Int(			INI_SECTION_NAME, "TimeLimitMinutes",			Get_Time_Limit_Minutes());
   p_ini->Put_Int(	   	INI_SECTION_NAME, "RadarMode",					Get_Radar_Mode());
   //p_ini->Put_Int(	   	INI_SECTION_NAME, "IntermissionTimeSeconds",	Get_Intermission_Time_Seconds());
   p_ini->Put_Int(			INI_SECTION_NAME, "Port",							Get_Port());
	p_ini->Put_Bool(			INI_SECTION_NAME, "IsDedicated",					IsDedicated.Get());
	p_ini->Put_Bool(			INI_SECTION_NAME, "IsAutoRestart",				IsAutoRestart.Get());
	p_ini->Put_Bool(			INI_SECTION_NAME, "IsPassworded",				IsPassworded.Get());
	p_ini->Put_Bool(			INI_SECTION_NAME, "IsQuickMatch",				IsQuickMatchServer.Get());
	p_ini->Put_Bool(			INI_SECTION_NAME, "IsLaddered",					IsLaddered.Get());
	p_ini->Put_Bool(			INI_SECTION_NAME, "IsClanGame",					IsClanGame.Get());
	p_ini->Put_Bool(			INI_SECTION_NAME, "RemixTeams",					RemixTeams.Get());
	p_ini->Put_Bool(			INI_SECTION_NAME, "CanRepairBuildings",		CanRepairBuildings.Get());
	p_ini->Put_Bool(			INI_SECTION_NAME, "DriverIsAlwaysGunner",		DriverIsAlwaysGunner.Get());
	p_ini->Put_Bool(			INI_SECTION_NAME, "SpawnWeapons",				SpawnWeapons.Get());
	//p_ini->Put_Bool(			INI_SECTION_NAME, "IsClientTrusted",			IsClientTrusted.Get());
	p_ini->Put_Bool(			INI_SECTION_NAME, "UseLagReduction",			IsClientTrusted.Get());
   p_ini->Put_Wide_String(	INI_SECTION_NAME, "wGameTitle",					Get_Game_Title());
   p_ini->Put_Wide_String(	INI_SECTION_NAME, "wMOTD",							Get_Motd());
#if (0)
	// Save out 8 bit string versions too.
	StringClass string8(256, true);
	WideStringClass(Get_Game_Title(), true).Convert_To(string8);
   p_ini->Put_String(		INI_SECTION_NAME, "bGameTitle",					string8);
	WideStringClass(Get_Motd(), true).Convert_To(string8);
   p_ini->Put_String(		INI_SECTION_NAME, "bMOTD",							string8);
	WideStringClass(Get_Password(), true).Convert_To(string8);
   p_ini->Put_String(		INI_SECTION_NAME, "bPassword",						string8);
#endif //(0)

	for (int j = 0; j < MAX_MAPS; j++) {
		StringClass item_name(0,true);
		item_name.Format("MapName%02d", j);
		p_ini->Put_String(	INI_SECTION_NAME, item_name,					MapCycle[j]);
	}

	if (!Motd.Is_Empty()) {
		StringClass motd;
		Motd.Convert_To(motd);
		p_ini->Put_String(	INI_SECTION_NAME, "Motd", motd.Peek_Buffer());
	}

	Save_INI(p_ini, config_file);
   Release_INI(p_ini);
}

//-----------------------------------------------------------------------------
void cGameData::Soldier_Added(SoldierGameObj * p_soldier)
{
	WWASSERT(p_soldier != NULL);

	if (IsFreeWeapons.Is_True() &&
		 p_soldier->Get_Player_Type() != PLAYERTYPE_NEUTRAL) {

		p_soldier->Give_All_Weapons();
		int weapon = 0;

		if (p_soldier->Is_Human_Controlled()) {
			weapon = 1;
		} else {
			weapon = 1 + rand() % 7;
		}

		WWASSERT(p_soldier->Get_Weapon_Bag() != NULL);
		p_soldier->Get_Weapon_Bag()->Select_Key_Number(weapon);
	}
}

//-----------------------------------------------------------------------------
void cGameData::Begin_Intermission(void)
{
	// If we are transitioning from one game to another we must first end the
	// previous game.
	GameModeClass* gameMode = GameModeManager::Find("WOL");

	if (gameMode && gameMode->Is_Active()) {
		WolGameModeClass* wolGame = reinterpret_cast<WolGameModeClass*>(gameMode);
		wolGame->End_Game();
	}

	IsIntermission.Set(true);
   IntermissionTimeRemaining = Get_Intermission_Time_Seconds();

	//
	//	Display a dialog with the win information on it
	//
	if (!ConsoleBox.Is_Exclusive()) {
		START_DIALOG (CNCWinScreenMenuClass);
	}
	return ;
}

//-----------------------------------------------------------------------------
void cGameData::Set_Maximum_World_Distance(float distance)
{
	//
	//	You will typically get this assert if you don't have the level file.
	//
	WWASSERT(distance > 0);
	MaximumWorldDistance = distance;
}

//-----------------------------------------------------------------------------
void cGameData::Set_Min_Qualifying_Time_Minutes(int minutes)
{
	WWASSERT(minutes >= 0);
	MinQualifyingTimeMinutes = minutes;
}

//-----------------------------------------------------------------------------
int cGameData::Get_Duration_Seconds(void)
{
	return (int)(TimeLimitMinutes * 60 - TimeRemainingSeconds);
}

//-----------------------------------------------------------------------------
WideStringClass cGameData::Get_Team_Word(void)
{
	//
	// In clan games, the work "Clan" is used instead of "Team"
	//

	if (IsClanGame.Is_True()) {
		return TRANSLATION(IDS_MP_CLAN);
	} else {
		return TRANSLATION(IDS_MP_TEAM);
	}
}

//-----------------------------------------------------------------------------
void cGameData::Set_Time_Remaining_Seconds(float time_remaining_seconds)
{
   WWASSERT(time_remaining_seconds >= 0);

	TimeRemainingSeconds = time_remaining_seconds;
}

//-----------------------------------------------------------------------------
void cGameData::Reset_Time_Remaining_Seconds(void)
{
	TimeRemainingSeconds = 60 * TimeLimitMinutes;
}

//-----------------------------------------------------------------------------
float cGameData::Get_Time_Remaining_Seconds(void)
{
	return TimeRemainingSeconds;
}

//-----------------------------------------------------------------------------
bool cGameData::Is_Valid_Player_Type(int player_type)
{
	bool is_valid = true;

	if (!Is_Single_Player()) {
		//if (player_type == PLAYERTYPE_RENEGADE &&
		//	 Is_Team_Game()) {
		if (player_type == PLAYERTYPE_RENEGADE) {
			is_valid = false;
		}

		/*
		if ((player_type == PLAYERTYPE_NOD || player_type == PLAYERTYPE_GDI) &&
			 !Is_Team_Game()) {
			is_valid = false;
		}
		*/
	}

	return is_valid;
}

//-----------------------------------------------------------------------------
int cGameData::Choose_Player_Type(cPlayer* player, int team_choice, bool is_grunt)
{
	if (IsClanGame.Is_True() && !is_grunt) {
		// Bots are assigned to the smallest team.
		if (player && !player->Is_Human()) {
			int team = Choose_Smallest_Team();

			WWDEBUG_SAY(("CLANS: Bot '%S' assigned to smallest team (%d)\n",
				(const WCHAR*)player->Get_Name(), team));

			return team;
		}

		// If there are other players from the same clan then team up them.
		// Otherwise we must be the first of our clan so select the next available team.
		cPlayer* clanMate = cPlayerManager::Find_Clan_Mate(player);

		if (clanMate) {
			int team = clanMate->Get_Player_Type();

			WWDEBUG_SAY(("CLANS: Player '%S' assigned to team with clanmates (%d)\n",
				(const WCHAR*)player->Get_Name(), team));

			return team;
		} else {
			int team = Choose_Available_Team(team_choice);

			WWDEBUG_SAY(("CLANS: Player '%S' assigned to available team (%d)\n",
				(const WCHAR*)player->Get_Name(), team));

			return team;
		}

		WWDEBUG_SAY(("CLANS: ERROR - Player not assigned to team\n"));
		WWASSERT("ERROR: Player not assigned to team");
	} else {
		if (PLAYERTYPE_RENEGADE == team_choice || IsTeamChangingAllowed.Is_False()) {
			return Choose_Smallest_Team();
		}
	}

	return team_choice;
}


int cGameData::Choose_Available_Team(int preference)
{
	// If the perferred team is available then use it.
	if (preference != -1) {
		cTeam* team = cTeamManager::Find_Team(preference);

		if (team && (team->Tally_Size() == 0)) {
			return team->Get_Id();
		}
	}

	// Find the next available team
	cTeam* team = cTeamManager::Find_Empty_Team();

	if (team) {
		return team->Get_Id();
	}

	WWDEBUG_SAY(("ERROR: No available team found\n"));
	WWASSERT("ERROR: No available team found");
	return -1;
}


//-----------------------------------------------------------------------------
int cGameData::Choose_Smallest_Team(void)
{
	//WWASSERT(Is_Team_Game());

	cTeam * p_team_0 = cTeamManager::Find_Team(0);
	WWASSERT(p_team_0 != NULL);
	cTeam * p_team_1 = cTeamManager::Find_Team(1);
	WWASSERT(p_team_1 != NULL);

	int team = -999;

	int size_team_0 = p_team_0->Tally_Size();
	int size_team_1 = p_team_1->Tally_Size();

	if (size_team_0 < size_team_1) {
		team = p_team_0->Get_Id();
	} else if (size_team_1 < size_team_0) {
		team = p_team_1->Get_Id();
	} else {
		//
		// Both teams are equal in size, so choose the losing team.
		//
		if (p_team_0->Get_Score() < p_team_1->Get_Score()) {
			team = p_team_0->Get_Id();
		} else if (p_team_0->Get_Score() > p_team_1->Get_Score()) {
			team = p_team_1->Get_Id();
		} else {
			//
			// Both teams have the same score. Choose Randomly.
			//
			if (rand() % 2 == 0) {
				team = p_team_0->Get_Id();
			} else {
				team = p_team_1->Get_Id();
			}
		}
	}

	WWASSERT(team != -999);

	return team;
}

//-----------------------------------------------------------------------------
bool cGameData::Is_Game_Over(void)
{
	WWASSERT(cNetwork::I_Am_Server());

	bool is_game_over = false;

   //
	// Games may be manually ended with the "gameover" command.
	//
	if (IsManualRestart) {
      IsManualRestart = false;
		WinType = WIN_TYPE_FORCED;
      is_game_over = true;
   }

	//
	// Games may be ended with the "quit" command.
	//
	if (!is_game_over && IsManualExit) {
		WinType = WIN_TYPE_FORCED;
      is_game_over = true;
	}

   //
   // Time expired?
   //
   if (!is_game_over && Is_Time_Limit() && TimeRemainingSeconds <= WWMATH_EPSILON)  {
		WinType = WIN_TYPE_TIME;
      is_game_over = true;
   }

	//
	// If game time has passed but gameplay now pends, end the game
	//
   if (!is_game_over && Get_Game_Duration_S() > 0 && !Is_Gameplay_Permitted())  {
		WinType = WIN_TYPE_FORCED;
      is_game_over = true;
   }

	/*
	//
	// THIS NEEDS REFINEMENT
	//
	// The following test will end a non-mission game when your opponents
	// abandon you. To determine whether any combat has occurred we simply
	// examine the IsBloodShed flag.
	//
	if (!Is_Mission() && IsBloodShed.Is_True() &&
      ((Is_Team_Game() && cTeamManager::Get_Living_Count() <= 1) ||
       (!Is_Team_Game() && cPlayerManager::Get_Living_Count() <= 1))) {
      return true;
   }
	*/

	if (is_game_over)
	{
		TimeRemainingSeconds = 0;
	}

	return is_game_over;
}




//-----------------------------------------------------------------------------
bool cGameData::Has_Config_File_Changed(void)
{
	unsigned long mod_time = Get_Config_File_Mod_Time();

	if (LastServerConfigModTime != mod_time) {
		return(true);
	}
	return(false);
}



//-----------------------------------------------------------------------------
unsigned long cGameData::Get_Config_File_Mod_Time(void)
{
	StringClass full_filename(IniFilename, true);
	RawFileClass file(full_filename);

	if (!file.Is_Available()) {
      full_filename.Format("data\\%s", IniFilename);
		file.Set_Name(full_filename);
   }

	if (file.Is_Available()) {
		file.Open();
		unsigned long mod_time = file.Get_Date_Time();
		file.Close();
		return(mod_time);
	}
	return(0);
}




//-----------------------------------------------------------------------------
void cGameData::Game_Over_Processing(void)
{
   WWDEBUG_SAY(("cGameData::Game_Over_Processing\n"));

	WWASSERT(cNetwork::I_Am_Server());

   int winning_team = cTeamManager::Get_Leaders_Id();

	//
	// Reload the game settings if they changed on disk.
	//
	if (Has_Config_File_Changed()) {
		//
		// Verify that the new settings are good.
		//
		cGameDataCnc *test_game_settings = (cGameDataCnc*) Create_Game_Of_Type(cGameData::GAME_TYPE_CNC);
		WWASSERT(test_game_settings != NULL);

		bool ok = false;

		if (test_game_settings) {
			test_game_settings->Set_Ini_Filename(IniFilename);
			test_game_settings->Load_From_Server_Config();

			WideStringClass outMsg;
			ok = test_game_settings->Is_Valid_Settings(outMsg, true);
			delete test_game_settings;
		}

		//
		// If they are good settings then reload them.
		//
		if (ok) {
			ConsoleBox.Print("Game settings changed - realoading settings\n");
			Load_From_Server_Config();
		}
	}

	Rotate_Map();

	cPlayerManager::Increment_Player_Times();

	//
	// Compute the game duration
	//
	DWORD duration_s = (int)((TIMEGETTIME() - GameStartTimeMs) / 1000.0f);
	Set_Game_Duration_S(duration_s);

	//
	// Record the MVP name and track the number of consecutives
	//
	WideStringClass mvp_name = cPlayerManager::Determine_Mvp_Name();
	if (mvp_name.Compare_No_Case(MvpName)) {
		Set_Mvp_Count(1);
		Set_Mvp_Name(cPlayerManager::Determine_Mvp_Name());
	} else {
		Increment_Mvp_Count();
	}

	mWinnerID = winning_team;

	cWinEvent * p_win = new cWinEvent;
	p_win->Init(mWinnerID, PLAYER_ID_UNKNOWN, IsMapCycleOver);

	cPlayerManager::Compute_Ladder_Points(winning_team);

	cTeamManager::Log_Team_List();
	cPlayerManager::Log_Player_List();

	//
	// Results logs wrap back to 1 after 100, and overwrite.
	//
	int log_num = cUserOptions::ResultsLogNumber.Get();
	log_num++;
	if (log_num > 100)
	{
		log_num = 1;
	}
	cUserOptions::ResultsLogNumber.Set(log_num);


	Begin_Intermission();
}

//-----------------------------------------------------------------------------
bool cGameData::Is_Gameplay_Permitted(void)
{
	bool permitted = true;

	if (IsIntermission.Is_True()) {
		permitted = false;
	}

	if (!GameModeManager::Find ("Combat")->Is_Active ()) {
		permitted = false;
	}

	return permitted;
}

void cGameData::Set_Clan(int slot, unsigned long clanID)
{
	WWASSERT(slot >= 0 && slot < MAX_CLAN_SLOTS);
	mClanSlots[slot] = clanID;
}


unsigned long cGameData::Get_Clan(int slot) const
{
	WWASSERT(slot >= 0 && slot < MAX_CLAN_SLOTS);
	return mClanSlots[slot];
}


void cGameData::Clear_Clans(void)
{
	for (int slot = 0; slot < MAX_CLAN_SLOTS; ++slot) {
		mClanSlots[slot] = 0;
	}
}


int cGameData::Find_Free_Clan_Slot(void) const
{
	if (IsClanGame.Is_True()) {
		for (int slot = 0; slot < MAX_CLAN_SLOTS; ++slot) {
			if (mClanSlots[slot] == 0) {
				return slot;
			}
		}
	}

	return -1;
}


bool cGameData::Is_Clan_Competing(unsigned long clanID) const
{
	if (IsClanGame.Is_True() && (clanID != 0)) {
		for (int slot = 0; slot < MAX_CLAN_SLOTS; ++slot) {
			if (mClanSlots[slot] == clanID) {
				return true;
			}
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
bool cGameData::Is_Clan_Game_Open(void) const
{
	if (IsClanGame.Is_True()) {
		for (int slot = 0; slot < MAX_CLAN_SLOTS; ++slot) {
			if (mClanSlots[slot] == 0) {
				return true;
			}
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
cGameData * cGameData::Create_Game_Of_Type(GameTypeEnum game_type)
{
	/*
	cGameData * p_game_data = NULL;

	switch (game_type) {
		//case GAME_TYPE_DEATHMATCH:			p_game_data = new cGameDataDeathMatch;			break;
		//case GAME_TYPE_TEAM_DEATHMATCH:	p_game_data = new cGameDataTeamDeathMatch;	break;
		case GAME_TYPE_CNC:					p_game_data = new cGameDataCnc;					break;
		default:									DIE;														break;
	}

	return p_game_data;
	*/

	WWASSERT(game_type == GAME_TYPE_CNC);

	return new cGameDataCnc;
}

/*
//-----------------------------------------------------------------------------
const char* cGameData::Get_Game_Type_Name(GameTypeEnum type)
{
	static const char* _modeNames[] = {"SP", "SK", "CNC"};
	return _modeNames[type];
}
*/

//-----------------------------------------------------------------------------
const char * cGameData::Get_Game_Type_Name(void) const
{
	WideStringClass wide_name;
	wide_name.Format(L"%s", Get_Game_Name());
	StringClass name;
	wide_name.Convert_To(name);

	return name.Peek_Buffer();
}

//-----------------------------------------------------------------------------
void cGameData::Add_Bottom_Text(WideStringClass & text)
{
	//WWASSERT(text != NULL);

/* 	WWASSERT(PFont != NULL);
	float x = Render2DClass::Get_Screen_Resolution().Center().X -
		PFont->String_Width(text) / 2.0f;

	float y = MultiHUDClass::Get_Bottom_Text_Y_Pos();
	y -= 1.2 * PFont->Char_Height();
	MultiHUDClass::Set_Bottom_Text_Y_Pos(y);

   WWASSERT(PTextRenderer != NULL);
	PTextRenderer->Set_Location(Vector2(cMathUtil::Round(x), cMathUtil::Round(y)));
	PTextRenderer->Draw_Text(text);
*/
	BottomText.Add(text);
}

//-----------------------------------------------------------------------------
void cGameData::Show_Game_Settings_Limits(void)
{
	if (PTextRenderer == NULL) {
		return;
	}

	bool changed=false;

	WideStringClass text(0,true);
	unsigned color;

	Get_Time_Limit_Text(text);
	if (text!=renderer_time_text) {
		renderer_time_text=text;
		changed=true;
	}

	// Dedicated server label
	if (cNetwork::I_Am_Only_Server()) {
		Get_Dedicated_Server_Label(text,color);
	}
	else {
		text="";
		color=0;
	}
	if (text!=renderer_dedicated_server_label) {
		renderer_dedicated_server_label=text;
		changed=true;
	}
	if (color!=renderer_dedicated_server_color) {
		renderer_dedicated_server_color=color;
		changed=true;
	}

	// Gameplay pending label -
	bool show_gameplay_label = false;
	if (!Is_Gameplay_Permitted() || (COMBAT_STAR == NULL))	{
		show_gameplay_label = true;
	}
	//if (IsIntermission.Is_False() && (!Is_Gameplay_Permitted() || (COMBAT_STAR == NULL))) {
	if (show_gameplay_label) {
		Get_Gameplay_Not_Permitted_Label(text,color);
	} else {
		text="";
		color=0;
	}
	if (text!=renderer_gameplay_label) {
		renderer_gameplay_label=text;
		changed=true;
	}
	if (color!=renderer_gameplay_color) {
		renderer_gameplay_color=color;
		changed=true;
	}

	if (!changed) {
		if (BottomText.Count()!=OldBottomText.Count()) {
			changed=true;
		}
		else {
			for (int j=0;j<BottomText.Count();++j) {
				if (BottomText[j]!=OldBottomText[j]) {
					changed=true;
					break;
				}
			}
		}
	}


	// Render if needed  -------------------------------------------------------
	float charHeight = PTextRenderer->Peek_Font()->Get_Char_Height();

	if (!changed) {
		// Proceed the multihud by one line (as we are caching the time render which would usually do this)
		float y = MultiHUDClass::Get_Bottom_Text_Y_Pos();
		y -= 1.2 * charHeight;
		MultiHUDClass::Set_Bottom_Text_Y_Pos(y);
		BottomText.Reset_Active();
		return;
	}

	// Re-compose the OldBottomText vector

	OldBottomText.Reset_Active();
	for (int j=0;j<BottomText.Count();++j) {
		OldBottomText.Add(BottomText[j]);
	}
	BottomText.Reset_Active();

	PTextRenderer->Reset();

	float x,y;

	// Render bottom text (start with time text, which is to be first)
	Vector2 textExtent = PTextRenderer->Get_Text_Extents(text);
	x = Render2DClass::Get_Screen_Resolution().Center().X -  textExtent.X / 2.0f;

	//Always draw on the bottom
	MultiHUDClass::Set_Bottom_Text_Y_Pos( Render2DClass::Get_Screen_Resolution().Bottom - 15 );

	y = MultiHUDClass::Get_Bottom_Text_Y_Pos();
	y -= 1.2 * charHeight;
	Vector2 loc(cMathUtil::Round(x), cMathUtil::Round(y));
	PTextRenderer->Set_Location(loc);
	PTextRenderer->Build_Sentence(renderer_time_text);
	PTextRenderer->Draw_Sentence();

	for (j=0;j<OldBottomText.Count();++j) {
		y -= 1.2 * charHeight;
		loc[1]=cMathUtil::Round(y);
		PTextRenderer->Set_Location(loc);
		PTextRenderer->Build_Sentence(OldBottomText[j]);
		PTextRenderer->Draw_Sentence();
	}
	MultiHUDClass::Set_Bottom_Text_Y_Pos(y);



	// Dedicated server label
	if (cNetwork::I_Am_Only_Server()) {
		Vector2 extent = PTextRenderer->Get_Text_Extents(renderer_dedicated_server_label);
		x = Render2DClass::Get_Screen_Resolution().Center().X - extent.X / 2.0f;

		y = Render2DClass::Get_Screen_Resolution().Center().Y;
		PTextRenderer->Set_Location(Vector2(cMathUtil::Round(x), cMathUtil::Round(y)));
		PTextRenderer->Build_Sentence(renderer_dedicated_server_label);
		PTextRenderer->Draw_Sentence(renderer_dedicated_server_color);
	}

	// Gameplay pending label
	if (show_gameplay_label) {
		Vector2 extent = PTextRenderer->Get_Text_Extents(renderer_gameplay_label);
		x = Render2DClass::Get_Screen_Resolution().Center().X -  extent.X / 2.0f;
		y = Render2DClass::Get_Screen_Resolution().Center().Y + 1.2 * charHeight;
		PTextRenderer->Set_Location(Vector2(cMathUtil::Round(x), cMathUtil::Round(y)));
		PTextRenderer->Build_Sentence(renderer_gameplay_label);
		PTextRenderer->Draw_Sentence(color);
	}
}

//-----------------------------------------------------------------------------
void cGameData::Get_Dedicated_Server_Label(WideStringClass& text, unsigned& color)
{
	color = 0xFFFFFFFF; // white
	if (cMathUtil::Round(TimeManager::Get_Seconds()) % 2 != 0) {
		color = 0xFF00FF00;	// green
	}

	text = TRANSLATION(IDS_MP_DEDICATED_SERVER);
}

//-----------------------------------------------------------------------------
void cGameData::Get_Gameplay_Not_Permitted_Label(WideStringClass& text, unsigned& color)
{
	color = 0xFFFFFFFF; // white
	if (cMathUtil::Round(TimeManager::Get_Seconds()) % 2 != 0) {
		color = 0xFF00FF00;	// green
	}

	text = TRANSLATION(IDS_MP_GAMEPLAY_PENDING);
}


//-----------------------------------------------------------------------------
void cGameData::Get_Time_Limit_Text(WideStringClass& text)
{
   if (IsIntermission.Is_True()) {

      text.Format(
			L"%s: %d",
			TRANSLATION(IDS_MP_NEXTGAME_COUNTDOWN),
			cMathUtil::Round(Get_Intermission_Time_Remaining()));

	} else if (Is_Time_Limit()) {

      int hours	= 0;
      int mins		= 0;
      int seconds	= 0;

		cMiscUtil::Seconds_To_Hms(TimeRemainingSeconds, hours, mins, seconds);

      WideStringClass time_string(0, true);
      time_string.Format(L"%02d:%02d:%02d", hours, mins, seconds);

		text.Format(L"%s: %s", TRANSLATION(IDS_MP_TIME_REMAINING), time_string);
   }

}

//-----------------------------------------------------------------------------
void cGameData::Think(void)
{
	if (IsIntermission.Is_True()) {
		IntermissionTimeRemaining -= TimeManager::Get_Frame_Real_Seconds();
		if (IntermissionTimeRemaining < 0) {

			IntermissionTimeRemaining = 0;
		}
	} else if (Is_Gameplay_Permitted()) {
		TimeRemainingSeconds -= TimeManager::Get_Frame_Real_Seconds();
		if (TimeRemainingSeconds < 0) {
			TimeRemainingSeconds = 0;
		}

		DWORD duration_s = (int)((TIMEGETTIME() - GameStartTimeMs) / 1000.0f);
		Set_Game_Duration_S(duration_s);
	}

	if (cNetwork::I_Am_Server()) {
		//
		// Update CurrentPlayers
		//
		int max = (int) WWMath::Max(
			cPlayerManager::Count(),
			cNetwork::PServerConnection->Get_Num_RHosts());
		Set_Current_Players(max);
	}

	DEMO_SECURITY_CHECK;

	FrameCount++;
}

//-----------------------------------------------------------------------------
void cGameData::Render(void)
{
	Show_Game_Settings_Limits();

	if (PTextRenderer != NULL) {
		WWPROFILE("cGameData::Render");
		PTextRenderer->Render();
	}
}

//-----------------------------------------------------------------------------
void cGameData::On_Game_Begin(void)
{
	//
	// Note, On_Game_Begin happens after load.
	//

   WWDEBUG_SAY(("cGameData::On_Game_Begin\n"));

	GetSystemTime(&GameStartTime);
	FrameCount = 0;

	GameStartTimeMs = TIMEGETTIME();

	//
	// Clear the MVP name
	// Let MVP carry over into next game.
	//
	//MvpName.Format(L"");
	//MvpCount = 0;

	//
	// Reset the game duration
	//
	GameDurationS = 0;

	//
	// Notify the combat layer about various server options
	//
	cCsDamageEvent::Set_Are_Clients_Trusted(IsClientTrusted.Get());
	BuildingGameObj::Set_Can_Repair_Buildings(CanRepairBuildings.Get());
	VehicleGameObj::Set_Default_Driver_Is_Gunner(DriverIsAlwaysGunner.Get());
	CombatManager::Set_Friendly_Fire_Permitted(IsFriendlyFirePermitted.Get());
	CombatManager::Set_Beacon_Placement_Ends_Game(false);

	//
	// Filter out unwanted spawners
	//
	if (cNetwork::I_Am_Server()) {
		Filter_Spawners();
	}

	//
	// Adjust teaming for auto-teamed games
	//
	//if (!IS_MISSION && cNetwork::I_Am_Server() && Is_Team_Game() && IsTeamChangingAllowed.Is_False()) {
	if (!IS_MISSION && cNetwork::I_Am_Server()) {

		if (IsClanGame.Is_False() && IsTeamChangingAllowed.Is_False() && RemixTeams.Is_True()) {
			//
			// Remix Teams if the server option is set.
			//
			Remix_Team_Sides();
		} else {
			//
			// In non-remixed C&C mode, we have a 50-50 chance of the teams being swapped. I prefer this
			// to simply alternating, because if you alternate and the number of maps in the
			// cycle is even, you will always play GDI on the same 50% of the maps.
			//
			if (Is_Skirmish() || (Is_Cnc() && (rand() % 2 == 0))) {
				Swap_Team_Sides();
			}
		}

		if (IsClanGame.Is_False() && IsTeamChangingAllowed.Is_False())
		{
			//
			// We always rebalance the teams numerically
			//
			Rebalance_Team_Sides();
		}
	}

	GameModeClass* gameMode = GameModeManager::Find("WOL");

	if (gameMode && gameMode->Is_Active()) {
		WolGameModeClass* wolGame = reinterpret_cast<WolGameModeClass*>(gameMode);
		WWASSERT(wolGame != NULL);
		wolGame->Start_Game(this);
	}
}

//-----------------------------------------------------------------------------
void cGameData::On_Game_End(void)
{
   WWDEBUG_SAY(("cGameData::On_Game_End\n"));

	GameModeClass* gameMode = GameModeManager::Find("WOL");

	if (gameMode && gameMode->Is_Active()) {
		WolGameModeClass* wolGame = reinterpret_cast<WolGameModeClass*>(gameMode);
		wolGame->End_Game();
	}
}

//-----------------------------------------------------------------------------
int	cGameData::Get_Mission_Number_From_Map_Name( const char * map_name )
{
	// If tutorial, return tutorial number
	if ( ::strnicmp( map_name, "M00_T", 5 ) == 0 ) {
		#define	TUTORIAL_LOAD_MENU_NUMBER		90
		return TUTORIAL_LOAD_MENU_NUMBER;
	}


	// Assume the map name is in the form "mXX.mix" where xx is the level number
	if ( ::strlen( map_name ) > 0 ) {
		return ::atoi( ((const char *)map_name)+1 );
	}
	return 0;
}

//-----------------------------------------------------------------------------
const StringClass& cGameData::Get_Map_Cycle(int map)
{
	WWASSERT(map >= 0 && map < MAX_MAPS);

#ifdef MULTIPLAYERDEMO
	MapCycle[map].Format("C&C_Under.mix");
#endif // MULTIPLAYERDEMO

	return MapCycle[map];
}

//-----------------------------------------------------------------------------
void
cGameData::Set_Map_Cycle(int map, const StringClass & map_name)
{
	WWASSERT(map >= 0 && map < MAX_MAPS);

	MapCycle[map] = map_name;
}

//-----------------------------------------------------------------------------
void
cGameData::Clear_Map_Cycle(void)
{
	for (int i = 0; i < MAX_MAPS; i++)
	{
		MapCycle[i].Format("");
	}
}

//-----------------------------------------------------------------------------
void
cGameData::Rotate_Map(void)
{
	IsMapCycleOver = false;

	//
	// Determine the current map
	//
	int current_map = MapCycleIndex;
#if (0)
	int current_map = 0;
	for (int i = 0; i < MAX_MAPS; i++)
	{
		if (MapName == MapCycle[i]) {
			current_map = i;
			break;
		}
	}
#endif //(0)
	
	//
	// Increment it
	//
	current_map++;

	//
	// Go back to the first map if necessary
	//
	if (current_map >= MAX_MAPS || MapCycle[current_map].Is_Empty()) {
		current_map = 0;

		if (DoMapsLoop == false) {
			IsMapCycleOver = true;
		}
	}

	//
	// Set the map name
	//
#ifdef MULTIPLAYERDEMO
	MapName.Format("C&C_Under.mix");
#else
	MapName = MapCycle[current_map];
#endif

	MapCycleIndex = current_map;

	return ;
}

//-----------------------------------------------------------------------------
void cGameData::Set_Win_Text(WideStringClass & text)
{
	WinText = text;
}

//-----------------------------------------------------------------------------
void cGameData::ReceiveSignal(MPChooseTeamSignal& choice)
{
	if (choice.GetItemA() == true) {
		//
		// Do nothing if the player selected 'auto' rather than GDI or NOD.
		//
		if (choice.GetItemB() != PLAYERTYPE_RENEGADE) {
			cNetwork::SwitchTeam(choice.GetItemB());
		}
	}
}

//-----------------------------------------------------------------------------
void cGameData::Filter_Spawners(void)
{
	WWASSERT(cNetwork::I_Am_Server());

	if (SpawnWeapons.Is_False()) {
		//
		// Disable multiplay weapons spawners
		//
		DynamicVectorClass<SpawnerClass*> spawner_list = SpawnManager::Get_Spawner_List();

		for (int i = 0; i < spawner_list.Count(); i++) {

			WWASSERT(spawner_list[i] != NULL);

			if (spawner_list[i]->Get_Definition().Is_Multiplay_Weapon_Spawner()) {
				spawner_list[i]->Enable(false);
			}
		}
	}
}

//------------------------------------------------------------------------------------
void cGameData::Set_Mvp_Name(const WideStringClass name)
{
	MvpName = name;
}

//------------------------------------------------------------------------------------
void cGameData::Set_Mvp_Count(int count)
{
	WWASSERT(count >= 0);

	MvpCount = count;
}

//------------------------------------------------------------------------------------
void cGameData::Set_Win_Type(WinTypeEnum type)
{
	WinType = type;
}

//------------------------------------------------------------------------------------
void cGameData::Set_Game_Duration_S(DWORD seconds)
{
	GameDurationS = seconds;
}

//-----------------------------------------------------------------------------
void cGameData::Get_Description(WideStringClass & description)
{
	const WideStringClass delimiter	= L"\t";
	const WideStringClass newline		= L"\n";
	const WideStringClass yes			= TRANSLATE(IDS_YES);
	const WideStringClass no			= TRANSLATE(IDS_NO);

	WideStringClass attribute(0, true);
	WideStringClass value(0, true);

	//
	// Host
	//
	attribute = TRANSLATE(IDS_MP_HOST);
	value = Owner;
	description += (attribute + delimiter + value + newline);

	//
	// Game Name
	//
	attribute = TRANSLATE(IDS_MENU_TEXT292);
	value = GameTitle;
	description += (attribute + delimiter + value + newline);

	//
	// Map Name
	//
	if (ModName.Is_Empty () == false) {
		attribute = L"Mod Name:";
		value = ModName;
		description += (attribute + delimiter + value + newline);
	}

	//
	// Map Name
	//
	attribute = TRANSLATE(IDS_MP_GAME_LIST_HEADER_GAME_MAP);
	value = MapName;
	description += (attribute + delimiter + value + newline);

	//
	// Time Limit
	//
	attribute = TRANSLATE(IDS_MENU_TEXT298);
	if (Is_Time_Limit()) {
		value.Format(L"%d %s", TimeLimitMinutes, TRANSLATE(IDS_MP_MINUTES));
	} else {
		value = TRANSLATE(IDS_MP_NONE);
	}
	description += (attribute + delimiter + value + newline);

	//
	// Max. Players
	//
	attribute = TRANSLATE(IDS_MENU_TEXT294);
	value.Format(L"%d", MaxPlayers);
	description += (attribute + delimiter + value + newline);

	//
	// Radar
	//
	attribute = TRANSLATE(IDS_MENU_TEXT488);
	switch (RadarMode) {
		case RADAR_NOBODY:
		   value = TRANSLATION(IDS_MP_RADAR_MODE_NOBODY);
			break;

		case RADAR_TEAMMATES:
		   value = TRANSLATION(IDS_MP_RADAR_MODE_TEAMMATES);
			break;

		case RADAR_ALL:
		   value = TRANSLATION(IDS_MP_RADAR_MODE_ALL);
			break;

		default:
			DIE;
	}
	description += (attribute + delimiter + value + newline);

	//
	// Allow Quickmatching
	//
	attribute = TRANSLATE(IDS_MENU_TEXT584);
	value = (IsQuickMatchServer.Get() ? yes : no);
	description += (attribute + delimiter + value + newline);

	//
	// Dedicated
	//
	attribute = TRANSLATE(IDS_MENU_TEXT309);
	value = (IsDedicated.Get() ? yes : no);
	description += (attribute + delimiter + value + newline);

	//
	// Friendly Fire
	//
	attribute = TRANSLATE(IDS_MENU_TEXT301);
	value = (IsFriendlyFirePermitted.Get() ? yes : no);
	description += (attribute + delimiter + value + newline);

	//
	// Manual Teaming
	//
	attribute = TRANSLATE(IDS_MENU_TEXT490);
	value = (IsTeamChangingAllowed.Get() ? yes : no);
	description += (attribute + delimiter + value + newline);

	//
	// Passworded
	//
	attribute = TRANSLATE(IDS_MP_PASSWORDED);
	value = (IsPassworded.Get() ? yes : no);
	description += (attribute + delimiter + value + newline);

	//
	// Laddered
	//
	attribute = TRANSLATE(IDS_MENU_TEXT496);
	value = (IsLaddered.Get() ? yes : no);
	description += (attribute + delimiter + value + newline);

	//
	// Clan Game
	//
	attribute = TRANSLATE(IDS_MENU_TEXT497);
	value = (IsClanGame.Get() ? yes : no);
	description += (attribute + delimiter + value + newline);

	/*
	//
	// Trust Clients
	//
	attribute = TRANSLATE(IDS_MENU_TEXT585);
	value = (IsClientTrusted.Get() ? yes : no);
	description += (attribute + delimiter + value + newline);
	*/

	//
	// Remix Teams
	//
	attribute = TRANSLATE(IDS_MENU_TEXT587);
	value = (RemixTeams.Get() ? yes : no);
	description += (attribute + delimiter + value + newline);

	//
	// Can Repair Buildings
	//
	attribute = TRANSLATE(IDS_MENU_TEXT590);
	value = (CanRepairBuildings.Get() ? yes : no);
	description += (attribute + delimiter + value + newline);

	//
	// Driver Is Always Gunner
	//
	attribute = TRANSLATE(IDS_MENU_TEXT591);
	value = (DriverIsAlwaysGunner.Get() ? yes : no);
	description += (attribute + delimiter + value + newline);

	//
	// Weapon spawning
	//
	attribute = TRANSLATE(IDS_MENU_TEXT592);
	value = (SpawnWeapons.Get() ? yes : no);
	description += (attribute + delimiter + value + newline);
}

//-----------------------------------------------------------------------------

//cGameData *						The_Game(void)							{WWASSERT(PTheGameData != NULL); return PTheGameData;}
cGameData *						The_Game(void)							{return PTheGameData;}

cGameDataSinglePlayer *		The_Single_Player_Game(void)		{WWASSERT(The_Game()->As_Single_Player() != NULL);		return The_Game()->As_Single_Player();}
cGameDataSkirmish *			The_Skirmish_Game(void)				{WWASSERT(The_Game()->As_Skirmish() != NULL);			return The_Game()->As_Skirmish();}
cGameDataCnc *					The_Cnc_Game(void)					{WWASSERT(The_Game()->As_Cnc() != NULL);					return The_Game()->As_Cnc();}







	/*
	if (Is_Team_Game()) {
		has_opponents =
			cPlayerManager::Get_Count(PLAYERTYPE_NOD) > 0 &&
			cPlayerManager::Get_Count(PLAYERTYPE_GDI) > 0;
	} else {
		has_opponents = (cPlayerManager::Get_Count(PLAYERTYPE_RENEGADE) > 1);
	}
	*/

/*
//-----------------------------------------------------------------------------
void cGameData::Set_Min_Game_Time_Required_Mins(int mins)
{
	WWASSERT(mins >= 0 );
	MinGameTimeRequiredMins = mins;
}
*/

/*
//-----------------------------------------------------------------------------
void cGameData::Set_Full_Score_Time_Threshold_Mins(int mins)
{
	WWASSERT(mins >= 0);
	FullScoreTimeThresholdMins = mins;
}
*/

//#include "helptext.h"
//#include "gddeathmatch.h"
//#include "gdteamdeathmatch.h"
	//MinGameTimeRequiredMins			= 10;
	//FullScoreTimeThresholdMins		= 30;
	//MinGameTimeRequiredMins			= rhs.MinGameTimeRequiredMins;
	//FullScoreTimeThresholdMins		= rhs.FullScoreTimeThresholdMins;
   //packet.Add(MinGameTimeRequiredMins);
   //packet.Add(FullScoreTimeThresholdMins);
   //Set_Min_Game_Time_Required_Mins(			packet.Get(i_placeholder));
   //Set_Full_Score_Time_Threshold_Mins(		packet.Get(i_placeholder));
//cGameDataDeathMatch *		The_Deathmatch_Game(void)			{WWASSERT(The_Game()->As_Deathmatch() != NULL);			return The_Game()->As_Deathmatch();}
//cGameDataTeamDeathMatch *	The_Team_Deathmatch_Game(void)	{WWASSERT(The_Game()->As_Team_Deathmatch() != NULL);	return The_Game()->As_Team_Deathmatch();}

	//if (Is_Team_Game()) {
	/*
	} else {
		has_opponents = (cPlayerManager::Tally_Team_Size(PLAYERTYPE_RENEGADE) > 1);
	}
	*/

	//IsBloodShed.Set(					false);
	//IsBloodShed							= rhs.IsBloodShed;

   /*
	if (cNetwork::I_Am_Server()) {
		IsBloodShed.Set(false);
   }
	*/