/************************************************************************
*  游戏剧情的章节转换
************************************************************************/
void Controller::ChangeChapter(int nChapterID)
{
	if (nChapterID != CHAPTER_1 && nChapterID != CHAPTER_2 && nChapterID != CHAPTER_3 && nChapterID != CHAPTER_4)
	{
		return;
	}

	vector<Player*> playerList = Game()->GetPlayerManager()->GetPlayerList();
	if (m_nCurrentChapter != CHAPTER_0)
	{
		for (int i = 0; i < playerList.size(); ++i)
		{
			playerList[i]->Action(CodeMsg::code_player_static,right_direction);
		}
	}
	// 设置当前章节的ID
	m_nCurrentChapter = nChapterID;

	

	// 先让玩家停止
	

	// 暂停游戏
	SuspendGame();

	// 移除地图上所有的怪物 
	Game()->GetMonsterManager()->RemoveAllMonster();					

	// 移除地图上所有的装备
	Game()->GetEquipmentManager()->RemoveAllEquipment();			

	// 当前选中的怪物置为空
	m_pCurrentSelectedMonster = 0;														

	// 新建一个boss（每个章节的Boss都不一样）
	m_pBoss = Game()->GetMonsterManager()->CreateBoss();				

	// 场景转换
	Game()->GetSceneManager()->ChangeScene(nChapterID);				

	// 继续游戏
	ContinueGame();
}

bool CGameWindow::KeyPress(int c)
{
	if (BaseClass::KeyPress(c))
		return true;

	if (GameServer() && GameServer()->GetCamera())
		GameServer()->GetCamera()->KeyDown(c);

	if (Game())
	{
		for (size_t i = 0; i < Game()->GetNumLocalPlayers(); i++)
		{
			CPlayer* pPlayer = Game()->GetLocalPlayer(i);
			pPlayer->KeyPress(c);
		}
	}

	return false;
}

void CGameServer::SetClientNickname(int iClient, const tstring& sNickname)
{
	if (iClient == GetClientIndex() && Game()->GetNumLocalPlayers())
	{
		Game()->GetLocalPlayer(0)->SetPlayerName(sNickname);
		return;
	}

	for (size_t i = 0; i < Game()->GetNumPlayers(); i++)
	{
		if (Game()->GetPlayer(i)->GetClient() == iClient)
		{
			Game()->GetPlayer(i)->SetPlayerName(sNickname);
			return;
		}
	}

	TMsg(sprintf(tstring("Can't find client %d to give nickname %s.\n"), iClient, sNickname.c_str()));
}

void CGameServer::RestartLevel()
{
	SetLoading(false);
	AllowPrecaches();
	DestroyAllEntities(tvector<tstring>(), true);
	m_bRestartLevel = true;
	Game()->SetupGame(CVar::GetCVarValue("game_mode"));
	m_bRestartLevel = false;
	SetLoading(false);
}

void CGame::Load()
{
	m_iMonsterTexture = GetRenderer()->LoadTextureIntoGL("monster.png");
	m_iCrateTexture = GetRenderer()->LoadTextureIntoGL("crate.png");
	m_iNormalTexture = GetRenderer()->LoadTextureIntoGL("normal.png");

	GraphReset();

	m_projectile_initial_time = Game()->GetTime();
	m_projectile_initial_position = Vector(2, 1, 2);
	m_projectile_initial_velocity = Vector(-1, 3, -1) * 5;
	m_projectile_gravity = Vector(0, -5, 0);
	m_projectile_break_time = Game()->GetTime() + PredictProjectileMaximumHeightTime(m_projectile_initial_velocity, m_projectile_gravity);
	m_projectile_number = 1;

	// Fire the first one
	m_projectile_position[0] = m_projectile_initial_position;
	m_projectile_velocity[0] = m_projectile_initial_velocity;
}

Game RoxdokuGame::createGame(int difficulty, int symmetry) {
	if(!m_graph) {
		m_graph = new SKGraph(m_order, TypeRoxdoku);
		m_graph->initRoxdoku();
	}

	Puzzle* puzzle = new Puzzle(m_graph, true);
	puzzle->init(difficulty, symmetry);

	return Game(puzzle);
}

bool CGameServer::LoadFromFile(const tchar* pFileName)
{
	if (!GameServer())
		return false;

	GameServer()->Initialize();

	// Erase all existing entites. We're going to load in new ones!
	GameServer()->DestroyAllEntities();

	std::ifstream i;
	i.open(pFileName, std::ios_base::binary|std::ios_base::in);

	char szTag[8];
	i.read(szTag, 8);
	if (strncmp(szTag, "GameSave", 8) != 0)
		return false;

	CGameServer* pGameServer = GameServer();

	size_t iLoadCRC;
	i.read((char*)&iLoadCRC, sizeof(iLoadCRC));

	if (iLoadCRC != pGameServer->m_iSaveCRC)
		return false;

	i.read((char*)&pGameServer->m_flGameTime, sizeof(pGameServer->m_flGameTime));

	size_t iEntities;
	i.read((char*)&iEntities, sizeof(iEntities));

	for (size_t j = 0; j < iEntities; j++)
	{
		if (!CBaseEntity::UnserializeEntity(i))
			return false;
	}

	for (size_t i = 0; i < GameServer()->GetMaxEntities(); i++)
	{
		if (!CBaseEntity::GetEntity(i))
			continue;

		CBaseEntity::GetEntity(i)->ClientEnterGame();
	}

	Game()->EnterGame();

	if (GameServer()->GetWorkListener())
		GameServer()->GetWorkListener()->SetAction("Encountering resistance", 0);

	GameServer()->SetLoading(false);

	return true;
}

void COverlappedWindow::startNewGame() {
	getGameInfo().isFirstNextStep = true;

	setWindowSize();

	game = Game(getGameInfo().widthGridNumber, getGameInfo().heightGridNumber);
	isGameStarted = true;
	isDoneFirstStep = false;

	::InvalidateRect(handle, 0, 0);
}

void CUIMpTradeWnd::OnBtnOkClicked(CUIWindow* w, void* d)
{
	DeleteHelperItems();
	CheckDragItemToDestroy				();
	StorePreset							(_preset_idx_last, true, false, false);
	HideDialog							();
	game_cl_mp* clgame					= smart_cast<game_cl_mp*>(&(Game()));
	VERIFY(clgame);
	clgame->OnBuyMenu_Ok					();
//.	StorePreset							(_preset_idx_last, true, true);
}

bool CActor::CanSprint			()
{
	bool can_Sprint = CanAccelerate() && !conditions().IsCantSprint() &&
						Game().PlayerCanSprint(this)
						&& CanRun()
						&& !(mstate_real&mcLStrafe || mstate_real&mcRStrafe)
						&& InventoryAllowSprint()
						;

	return can_Sprint;
}

int game_cl_Deathmatch::GetPlayersPlace			(game_PlayerState* ps)
{
	if (!ps) return -1;
	game_cl_GameState::PLAYERS_MAP_IT I=Game().players.begin();
	game_cl_GameState::PLAYERS_MAP_IT E=Game().players.end();

	// create temporary map (sort by kills)
	xr_vector<game_PlayerState*>	Players;
	for (;I!=E;++I)		Players.push_back(I->second);
	std::sort			(Players.begin(),Players.end(),DM_Compare_Players);

	int Place = 1;
	for (u32 i=0; i<Players.size(); i++)
	{
		if (Players[i] == ps)
			return Place;
		Place++;
	};
	return -1;
}

s32 UITeamState::GetSummaryFrags() const
{
	typedef game_cl_GameState::PLAYERS_MAP::const_iterator PlCIter;
	game_cl_GameState::PLAYERS_MAP & playersMap = Game().players;
	
	s32		sum = 0;
	PlCIter	eiter = playersMap.end();

	for (PlCIter i = playersMap.begin(); i != eiter; ++i)
	{
		game_PlayerState*	ps = i->second;
		if (!ps)
			continue;
		game_cl_mp* tempGame = smart_cast<game_cl_mp*>(&Game());
		R_ASSERT(tempGame);
		if (static_cast<ETeam>(tempGame->ModifyTeam(ps->team)) == myTeam)
			sum = sum + ps->m_iRivalKills;
	}
	return sum;
}

/*
===============
idCommonLocal::NetReceiveUsercmds
===============
*/
void idCommonLocal::NetReceiveUsercmds( int peer, idBitMsg& msg )
{
	int clientNum = Game()->MapPeerToClient( peer );
	if( clientNum == -1 )
	{
		idLib::Warning( "NetReceiveUsercmds: Could not find client for peer %d", peer );
		return;
	}
	
	NetReadUsercmds( clientNum, msg );
}

int CALLBACK WinMain( HINSTANCE /*hInstance*/, HINSTANCE /*hPrevInstance*/, LPSTR /*lpCmdLine*/, int /*nCmdShow*/ )
{
	#ifndef NDEBUG
		int flag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG ); /* Get current flag */
		flag ^= _CRTDBG_LEAK_CHECK_DF; /* Turn on leak-checking bit */
		_CrtSetDbgFlag( flag ); /* Set flag to the new value */
	#endif

    Game();

	return 0;
}

void ShowStatus(class CCommand* pCommand, tvector<tstring>& asTokens, const tstring& sCommand)
{
	TMsg(tstring("Level: ") + CVar::GetCVarValue("game_level") + "\n");
	TMsg(sprintf(tstring("Clients: %d Entities: %d/%d\n"), GameNetwork()->GetClientsConnected(), CBaseEntity::GetNumEntities(), GameServer()->GetMaxEntities()));

	for (size_t i = 0; i < Game()->GetNumPlayers(); i++)
	{
		const CPlayer* pPlayer = Game()->GetPlayer(i);
		if (!pPlayer)
			continue;

		if (pPlayer->GetClient() < 0)
			TMsg("Local: ");
		else
			TMsg(sprintf(tstring("%d: "), pPlayer->GetClient()));

		TMsg(pPlayer->GetPlayerName());

		TMsg("\n");
	}
}

/************************************************************************
*  初始化函数
************************************************************************/
void Controller::Init(const string& strID,const string& strPsd,bool bNetMode)
{
	m_pCurrentSelectedMonster	= 0;								// 当前用鼠标右键选中的怪物

	m_nCurrentChapter					= CHAPTER_0;				// 游戏剧情的章节

	m_bLoopGame							= true;							// 游戏循环标志

	m_bIsNetGame							= bNetMode;

	SetMyPlayerInfo(strID,strPsd);

	RPG_01::Game()->ChangeChapter(CHAPTER_1);

	if (m_bIsNetGame)
	{
		Game()->GetNetworkModule()->Born();

		Game()->GetNetworkModule()->RequestAllOnlinePlayer();
	}
}

int main(int argc, char* argv[])
{
    const char* rendererFlag = getCmdOption(argv, argv + argc, "--renderer");
    
    auto game = Game();
    if(game.Init(rendererFlag))
    {
        game.Loop();
    }
    game.Terminate();
    return 0;
}

int main(){


	team A, B;


	Game(A, B);


	return 0;

}

bool CUISpeechMenu::OnKeyboardAction(int dik, EUIMessages keyboard_action)
{
    if (dik < DIK_1 || dik > DIK_0)
		return CUIDialogWnd::OnKeyboardAction(dik, keyboard_action);

	game_cl_mp* game = smart_cast<game_cl_mp*>(&Game());

	HideDialog();
	game->OnMessageSelected(this, static_cast<u8>(dik - DIK_1));

	return true;
}

void CChangeLevelWnd::OnOk()
{
	Game().StartStopMenu					(this, true);
	NET_Packet								p;
	p.w_begin								(M_CHANGE_LEVEL);
	p.w										(&m_game_vertex_id,sizeof(m_game_vertex_id));
	p.w										(&m_level_vertex_id,sizeof(m_level_vertex_id));
	p.w_vec3								(m_position);
	p.w_vec3								(m_angles);

	Level().Send							(p,net_flags(TRUE));
}