GUnitViewer* GUnitViewer::CreateUnitViewer(GnList<GUserHaveItem::Item>& cUnitItems)
{
GetGameState()->SetGameScale( 0.7f );
GUnitViewer* thisObject = GnNew GUnitViewer();
GnListIterator<GUserHaveItem::Item> iter = cUnitItems.GetIterator();
gtint itemCount = 0;
while( iter.Valid() )
{
guint32 unitIndex = iter.Item().mIndex;
gchar idName[16] = { 0, };
GetFileList()->GetForcesFileName( (gtuint)unitIndex, idName, sizeof( idName ) );
GForcesController* controller = GForcesController::Create( idName, 1 );
if( controller )
{
GnVector2 pos( 340.0f, 150.0f );
if( itemCount == 0 )
pos.x -= 10.0f;
controller->SetPosition( pos );
controller->GetMesh()->SetVisible( false );
thisObject->AddMeshToParentNode( controller->GetMesh() );
controller->GetActor()->SetTargetAnimation( GAction::ANI_ATTACK );
thisObject->AddActorCtlr( unitIndex, controller );
}
iter.Forth();
++itemCount;
}
GetGameState()->SetGameScale( 1.0f );
return thisObject;
}
//-----------------------------------------------------------------------------------
void TheGame::Render()
{
Renderer::instance->ClearScreen(0.3f, 0.3f, 0.3f);
Renderer::instance->BeginOrtho(Vector2::ZERO, Vector2(1600, 900));
Renderer::instance->DrawText2D(Vector2(0, 0), GetStateString(GetGameState()), 5.0f, RGBA::VAPORWAVE, true, BitmapFont::CreateOrGetFontFromGlyphSheet("Runescape"));
switch (GetGameState())
{
case GameState::GENERATION:
Renderer::instance->ClearScreen(0.3f, 0.3f, 0.3f);
RenderGeneration();
break;
case GameState::MAIN_MENU:
Renderer::instance->ClearScreen(RGBA::CORNFLOWER_BLUE);
RenderMainMenu();
break;
case GameState::MAP_SELECTION:
Renderer::instance->ClearScreen(RGBA::FOREST_GREEN);
RenderMapSelection();
break;
case GameState::PLAYING:
Renderer::instance->ClearScreen(RGBA::BLACK);
RenderPlaying();
break;
case GameState::PAUSED:
Renderer::instance->ClearScreen(RGBA::CORNFLOWER_BLUE);
RenderPaused();
break;
}
Renderer::instance->EndOrtho();
}
void CTetris::StartNewGame(void)
{
if (GetGameState() == GameRunning || GetGameState() == GamePaused)
EndGame(false);
m_curBrick = CreateRandomBrick();
if (!m_gameMusicInstance.isPlaying())
m_gameMusicInstance.play();
SetGameState(GameRunning);
}
GDialog* GDialog::CreateModalColor(GnInterface* pDlgInterface, const guchar ucR, const guchar ucG
, const guchar ucB, const guchar ucA)
{
CCLayerColor* colorLayer = CCLayerColor::layerWithColorWidthHeight( ccc4(ucR, ucG, ucB, ucA)
, GetGameState()->GetGameWidth(), GetGameState()->GetGameHeight() );
GLayer* glayer = new GLayer();
glayer->addChild( colorLayer, 0 );
glayer->AddChild( pDlgInterface, 1 );
GDialog* dlg = GnNew GDialog( pDlgInterface, glayer );
return dlg;
}
void CTetris::EndGame(bool stopMusic)
{
if (GetGameState() == GameRunning || GetGameState() == GamePaused)
{
delete m_curBrick;
m_curBrick = nullptr;
m_board = std::vector<std::vector<int>>(22, std::vector<int>(10, 0));
SetTimeSinceGravity(0.0f);
m_points = 0;
if (stopMusic)
m_gameMusicInstance.stop();
SetGameState(MainMenu);
}
}
// Return true if can see the planted bomb
bool CCSBot::CanSeePlantedBomb() const
{
if (TheCSBots()->GetScenario() != CCSBotManager::SCENARIO_DEFUSE_BOMB)
return false;
if (!GetGameState()->IsBombPlanted())
return false;
const Vector *bombPos = GetGameState()->GetBombPosition();
if (bombPos && IsVisible(bombPos, CHECK_FOV))
return true;
return false;
}
void Gn2DMeshObject::SetVectorExtraDataScale()
{
float* point;
GnVector2ExtraData* vector2Extra;
for( gtuint i = 0; i < GetExtraDataSize(); i++ )
{
vector2Extra = GnDynamicCast( GnVector2ExtraData, GetExtraData( i ) );
if( vector2Extra )
{
point = vector2Extra->GetValue();
point[0] *= GetGameState()->GetGameScale();
point[1] *= GetGameState()->GetGameScale();
}
}
}
void GSceneSelector::ReleaseScene()
{
if( mpCurrentScene == NULL )
return;
if( mpStartScene )
{
mpStartScene->release();
mpStartScene = NULL;
}
if( mpStateScene )
{
mpStateScene->release();
mpStateScene = NULL;
}
if( mpSelectStageScene )
{
mpSelectStageScene->release();
mpSelectStageScene = NULL;
}
if( mpGameScene )
{
mpGameScene->release();
mpGameScene = NULL;
GetGameState()->SetGameScale( 1.0 );
}
CCTextureCache::sharedTextureCache()->removeAllTextures();
}
bool Anonymize(char *name)
{
if(GetGameState()!=GAMESTATE_INGAME || !pLocalPlayer)
return 0;
BOOL bisTarget = false;
BOOL isRmember = false;
BOOL isGmember = false;
bool bChange = false;
int ItsMe = _stricmp(((PSPAWNINFO)pLocalPlayer)->Name, name);
if(ItsMe!=0)//well if it is me, then there is no point in checking if its a group member
isGmember = IsGroupMember(name);
if(!isGmember && ItsMe!=0)//well if it is me or a groupmember, then there is no point in checking if its a raid member
isRmember = IsRaidMember(name);
if (ItsMe != 0 && !isGmember && !isRmember) {
//my target?
if (pTarget && ((PSPAWNINFO)pTarget)->Type!=SPAWN_NPC) {
if (!_stricmp(((PSPAWNINFO)pTarget)->Name, name)) {
bisTarget = true;
}
}
}
if (ItsMe==0 || isGmember || isRmember || bisTarget) {
int len = strlen(name);
bChange = true;
for (int i = 1; i < len - 1; i++) {
name[i] = '*';
}
}
return bChange;
}
void CTetris::Update(double dt)
{
VE::IEntity::Update(dt);
if (GetGameState() == GameRunning)
ProcessGameRunning(dt);
}
/** This occurs when play begins */
void AMagicBattleSoccerBall::BeginPlay()
{
Super::BeginPlay();
if (Role < ROLE_Authority)
{
// The server manages the game state; the soccer ball will be replicated to us.
// Physics however are not replicated. We will need to have the ball orientation
// replicated to us. We need to turn off physics simulation and collision detection.
UPrimitiveComponent *Root = Cast<UPrimitiveComponent>(GetRootComponent());
Root->PutRigidBodyToSleep();
Root->SetSimulatePhysics(false);
Root->SetEnableGravity(false);
SetActorEnableCollision(false);
}
else
{
// Servers should add this soccer ball to the game mode cache.
// It will get replicated to clients for when they need to access
// the ball itself to get information such as who possesses it.
AMagicBattleSoccerGameState* GameState = GetGameState();
GameState->SoccerBall = this;
}
}
//-----------------------------------------------------------------------------------
void TheGame::Update(float deltaSeconds)
{
if (InputSystem::instance->WasKeyJustPressed('D'))
{
g_renderDebug = !g_renderDebug;
}
if(InputSystem::instance->WasKeyJustPressed('1'))
{
SetGameState(GameState::MAIN_MENU);
}
else if (InputSystem::instance->WasKeyJustPressed('2'))
{
SetGameState(GameState::MAP_SELECTION);
}
else if (InputSystem::instance->WasKeyJustPressed('3'))
{
SetGameState(GameState::GENERATION);
}
else if (InputSystem::instance->WasKeyJustPressed('4'))
{
SetGameState(GameState::PLAYING);
}
else if (InputSystem::instance->WasKeyJustPressed('5'))
{
SetGameState(GameState::PAUSED);
}
switch(GetGameState())
{
case GameState::MAIN_MENU:
UpdateMainMenu(deltaSeconds);
break;
case GameState::MAP_SELECTION:
EnvironmentBlueprint::LoadEnvironmentBlueprints();
UpdateMapSelection(deltaSeconds);
break;
case GameState::GENERATION:
UpdateGeneration(deltaSeconds);
break;
case GameState::PLAYING:
if (m_player == nullptr)
{
m_player = new Player();
SpawnInGame(m_player);
m_currentMap->UpdateFOVFrom(m_player->m_position, m_player->m_viewDistance);
for (int i = 0; i < NPCFactory::s_NPCFactories.size(); ++i)
{
NPC* enemyPointer = NPCFactory::GetNPCAt(i);
SpawnInGame(enemyPointer);
}
}
UpdatePlaying(deltaSeconds);
break;
case GameState::PAUSED:
UpdatePaused(deltaSeconds);
break;
}
MessageLog::instance->Update(deltaSeconds);
}
GScene* GSceneSelector::CreateGameScene()
{
bool success = false;
mpGameScene = new GGameScene();
do
{
if( mpGameScene->CreateScene( GetGameEnvironment()->GetStageInfo() ) == false )
break;
if( mpGameScene->InitEnvironment() == false )
break;
if( mpGameScene->CreateActorManager() == false )
break;
success = true;
}while(false);
GetGameState()->SetGameScale( 0.7 );
if( success == false )
{
delete mpGameScene;
mpGameScene = NULL;
return NULL;
}
return mpGameScene;
}
void CGame::DrawImageButton()
{
for (int i=0;i<m_imageButton.size();i++)
{
switch (GetGameState())
{
case PREPARE:
m_dcImage.SelectObject(m_bit[10+i*2]);
break;
case START:
m_dcImage.SelectObject(m_bit[17+i]);
break;
}
if ((m_whoCallHost==PLAYER_B&&m_gameState==PREPARE)||(m_whoSendCard==PLAYER_B&&m_gameState==START))
{
m_dcMask.SelectObject(m_bit[11]);
m_dcBuffer.BitBlt(m_imageButton[i].s_rcet.left,m_imageButton[i].s_rcet.top,82,40,&m_dcMask,0,0,SRCAND);
m_dcBuffer.BitBlt(m_imageButton[i].s_rcet.left,m_imageButton[i].s_rcet.top,82,40,&m_dcImage,82*m_imageButton[i].index,0,SRCPAINT);
}
}
}
void GameObject::Update()
{
double reward = 0;
if (!m_hasAgent) {
return;
}
// reorder the game states
if (m_oldGS != nullptr) {
delete m_oldGS;
m_oldGS = nullptr;
}
m_oldGS = m_newGS;
m_newGS = new GameState;
// construct the game state to pass to an agent
GetGameState(*m_newGS);
reward = 1 / std::max(1.d, m_newGS->m_distanceFromDestination);
// Discretize after reward calculation
m_newGS->discretize();
// get the agent for this object
QLearningAgent *agent = m_gw.m_game.GetAgent(m_id);
// Update the behaviors based on the last action
if (m_oldGS != 0) {
agent->update(*m_oldGS, m_lastAction, *m_newGS, reward);
}
if (m_pathToDest.size() == 0) {
Ogre::Vector3 a = GetLocation();
WorldPos curr = {a.x, a.z, 0};
m_gw.MakeMapPath(curr, m_pathToDest);
}
// here is where I'd pass the game state to an agent if we had one
// layout: turn, acceleration
m_lastAction = agent->getAction(*m_newGS);
std::cout << "Action: " << m_lastAction.m_accelerateMagnitude << ", " << m_lastAction.m_turnMagnitude << std::endl;
const dReal *quat = dBodyGetQuaternion(m_body);
// do physics things
if (quat[1] < 0.05f) {
dBodyAddRelForce(m_body, 0, 0, m_lastAction.m_accelerateMagnitude * m_maxForward);
dBodyAddTorque(m_body, 0, m_lastAction.m_turnMagnitude * m_maxTurn, 0);
}
// reset collision accumulator
m_totalDamage += m_collisionAccum;
m_collisionAccum = 0;
}
void CTetris::UnpauseGame(void)
{
if (GetGameState() == GamePaused)
{
SetGameState(GameRunning);
m_gameMusicInstance.play();
}
}
void CTetris::PauseGame(void)
{
if (GetGameState() == GameRunning)
{
SetGameState(GamePaused);
m_gameMusicInstance.stop();
}
}
Gn2DMeshObject* Gn2DMeshObject::Create(bool bUseGn2DMeshData)
{
Gn2DMeshObject* meshObject = NULL;
if( bUseGn2DMeshData )
meshObject = GnNew Gn2DMeshObject( new Gn2DMeshData() );
else
meshObject = GnNew Gn2DMeshObject( new GnReal2DMesh() );
meshObject->GetMesh()->setScale( GetGameState()->GetGameScale() );
meshObject->SetVisible( true );
meshObject->mMeshSize = GnVector2( 0.0f, 0.0f );
return meshObject;
}
GOpeningLayer* GOpeningLayer::CreateOpeningLayer(gtuint uiPage)
{
float width = GetGameState()->GetGameWidth();
float height = GetGameState()->GetGameHeight();
GOpeningLayer* openLayer = new GOpeningLayer();
for( gtuint i = 0 ; i < gscLastPage ; i++ )
{
gchar fileName[GN_MAX_PATH] = { 0, };
GnSprintf( fileName, sizeof( fileName ), "%d.png", uiPage + 1 );
gstring fullFileName;
GetFullPathFromWorkPath( fileName, fullFileName );
CCSprite* bg = CCSprite::spriteWithFile( fullFileName.c_str() );
bg->release();
}
gchar fileName[GN_MAX_PATH] = { 0, };
GnSprintf( fileName, sizeof( fileName ), "%d.png", uiPage + 1 );
gstring fullFileName;
GetFullPathFromWorkPath( fileName, fullFileName );
CCSprite* bg = CCSprite::spriteWithFile( fullFileName.c_str() );
bg->setPosition( CCPointMake( width / 2, height / 2 ) );
openLayer->addChild( bg );
GnInterfaceGroup* group = GnNew GnInterfaceGroup();
group->SetRect( 0.0f, 0.0f, width, height );
// next button
GnIButton* buttons = GnNew GnIButton( "17_402.png" );
SetUIPosition( buttons, 402.0f, 17.0f );
group->AddChild( buttons );
openLayer->AddChild( group, 1 );
group->SubscribeClickedEvent( &openLayer->mInputEvent );
openLayer->mCurrentPage = uiPage;
return openLayer;
}
void CNetGame::ProcessClientJoin(BYTE bytePlayerID)
{
// Perform all init operations.
if(GetGameState() == GAMESTATE_RUNNING) {
m_pVehiclePool->InitForPlayer(bytePlayerID); // give them all the existing vehicles
m_pPickupPool->InitForPlayer(bytePlayerID); // give them all the existing pickups
m_pObjectPool->InitForPlayer(bytePlayerID); // give them all the existing map objects
InitGameForPlayer(bytePlayerID);
m_pPlayerPool->InitPlayersForPlayer(bytePlayerID); // let them know who's on the server
m_pPlayerPool->InitSpawnsForPlayer(bytePlayerID); // spawn any existing players for them
m_pMenuPool->ResetPlayer(bytePlayerID); // Mark them as requiring menus
// Inform them of their VW as it doesn't actually work if called from OnPlayerConnect
// The server is updated but they're not connected fully so don't get it, so resend it
BYTE byteVW = m_pPlayerPool->GetPlayerVirtualWorld(bytePlayerID);
/*RakNet::BitStream bsData;
bsData.Write(bytePlayerID); // player id
bsData.Write(byteVW); // VW id
m_pRak->RPC(&RPC_ScrSetPlayerVirtualWorld, &bsData, HIGH_PRIORITY, RELIABLE, 0, UNASSIGNED_PLAYER_ID, true, false, UNASSIGNED_NETWORK_ID, NULL);
*/
}
else if(GetGameState() == GAMESTATE_RESTARTING)
{
InitGameForPlayer(bytePlayerID);
m_pPlayerPool->InitPlayersForPlayer(bytePlayerID); // let them know who's on the server
// Tell them that the world is currently restarting.
RakNet::BitStream bsParams;
PlayerID sender = m_pRak->GetPlayerIDFromIndex(bytePlayerID);
m_pRak->RPC(&RPC_GameModeRestart, &bsParams, HIGH_PRIORITY,
RELIABLE,0,sender,false,false, UNASSIGNED_NETWORK_ID, NULL);
}
//GetGameLogic()->HandleClientJoin(bytePlayerID);
//GetGameMode()->OnPlayerConnect(bytePlayerID);
}
void CNetGame::Packet_AimSync(Packet *p)
{
CPlayer * pPlayer = GetPlayerPool()->GetAt((BYTE)p->playerIndex);
RakNet::BitStream bsPlayerSync(p->data, p->length, false);
if(GetGameState() != GAMESTATE_RUNNING) return;
BYTE bytePacketID=0;
AIM_SYNC_DATA aimSync;
bsPlayerSync.Read(bytePacketID);
bsPlayerSync.Read((PCHAR)&aimSync,sizeof(AIM_SYNC_DATA));
if(pPlayer) {
pPlayer->StoreAimSyncData(&aimSync);
}
}
DWORD WINAPI GameStateWatcher::WorkerThread()
{
for(;;)
{
eGameState gameState = GetGameState();
if(gameState == GameStateRestartStory)
{
ExitProcess(0);
return 0;
}
Sleep(50);
}
return 1;
}
void CTetris::HardDrop(void)
{
if (GetGameState() != GameRunning)
return;
for (size_t r = 0; r < m_board.size(); ++r)
{
if (LockCheck())
{
LockCurBrick();
Update(GRAVITYTIME);
m_dropSound.play(1,1,1,ALLEGRO_PLAYMODE_ONCE);
break;
}
GetCurBrick()->SetCurRow(GetCurBrick()->GetCurRow() + 1);
}
}
// Return true if we are in a hurry
bool CCSBot::IsHurrying() const
{
if (!m_hurryTimer.IsElapsed())
return true;
// if the bomb has been planted, we are in a hurry, CT or T (they could be defusing it!)
if (TheCSBots()->GetScenario() == CCSBotManager::SCENARIO_DEFUSE_BOMB && TheCSBots()->IsBombPlanted())
return true;
// if we are a T and hostages are being rescued, we are in a hurry
if (TheCSBots()->GetScenario() == CCSBotManager::SCENARIO_RESCUE_HOSTAGES
&& m_iTeam == TERRORIST
&& GetGameState()->AreAllHostagesBeingRescued())
return true;
return false;
}
void CNetGame::Packet_SpectatorSync(Packet *p)
{
CPlayer * pPlayer = GetPlayerPool()->GetAt((BYTE)p->playerIndex);
RakNet::BitStream bsSpectatorSync(p->data, p->length, false);
if(GetGameState() != GAMESTATE_RUNNING) return;
BYTE bytePacketID=0;
SPECTATOR_SYNC_DATA spSync;
bsSpectatorSync.Read(bytePacketID);
bsSpectatorSync.Read((PCHAR)&spSync,sizeof(SPECTATOR_SYNC_DATA));
if(pPlayer) {
pPlayer->StoreSpectatorFullSyncData(&spSync);
}
}
Gn2DMeshObject* Gn2DMeshObject::CreateFromTextureFile(const gchar* pcFilePath)
{
gchar textureWorkPath[GN_MAX_PATH] = { 0, };
GnStrcpy( textureWorkPath, GnSystem::GetWorkDirectory(), sizeof(textureWorkPath) );
GnStrcat( textureWorkPath, pcFilePath, sizeof(textureWorkPath) );
GnReal2DMesh* mesh = CCSprite::spriteWithFile( textureWorkPath );
if( mesh == NULL )
{
mesh = CCSprite::spriteWithFile( pcFilePath );
if( mesh == NULL )
return NULL;
}
mesh->retain();
Gn2DMeshObject* meshObject = GnNew Gn2DMeshObject( mesh );
meshObject->GetMesh()->setScale( GetGameState()->GetGameScale() );
meshObject->Create2DAVData( meshObject->GetSize() );
CCSize size = mesh->getContentSize();
meshObject->mMeshSize = GnVector2( size.width, size.height );
return meshObject;
}
void CNetGame::Packet_PassengerSync(Packet *p)
{
CPlayer * pPlayer = GetPlayerPool()->GetAt((BYTE)p->playerIndex);
RakNet::BitStream bsPassengerSync(p->data, p->length, false);
if(GetGameState() != GAMESTATE_RUNNING) return;
BYTE bytePacketID=0;
PASSENGER_SYNC_DATA psSync;
bsPassengerSync.Read(bytePacketID);
bsPassengerSync.Read((PCHAR)&psSync,sizeof(PASSENGER_SYNC_DATA));
if(pPlayer) {
if(psSync.VehicleID == 0xFFFF) {
KickPlayer((BYTE)p->playerIndex);
return;
}
pPlayer->StorePassengerFullSyncData(&psSync);
}
}
DBOOL CBloodClientShell::SetGameState(int nState)
{
// Sanity checks...
if (!IsGameStateValid(nState)) return(DFALSE);
// Transition between the old and new state...
int nOldState = GetGameState();
int nNewState = nState;
if (!TransitionGameState(nOldState, nNewState))
{
return(DFALSE);
}
// All done...
return(DTRUE);
}
void CNetGame::Packet_VehicleSync(Packet *p)
{
CPlayer * pPlayer = GetPlayerPool()->GetAt((BYTE)p->playerIndex);
RakNet::BitStream bsVehicleSync(p->data, p->length, false);
if(GetGameState() != GAMESTATE_RUNNING) return;
BYTE bytePacketID=0;
INCAR_SYNC_DATA icSync;
bsVehicleSync.Read(bytePacketID);
bsVehicleSync.Read((PCHAR)&icSync,sizeof(INCAR_SYNC_DATA));
if(pPlayer) {
if(icSync.VehicleID == 0xFFFF) {
// Syncing a manually added/bad vehicle
KickPlayer((BYTE)p->playerIndex);
return;
}
pPlayer->StoreInCarFullSyncData(&icSync);
}
}
VOID PluginsAddSpawn(PSPAWNINFO pNewSpawn)
{
DWORD BodyType=GetBodyType(pNewSpawn);
PluginDebug("PluginsAddSpawn(%s,%d,%d)",pNewSpawn->Name,pNewSpawn->mActorClient.Race,BodyType);
if (!bPluginCS)
return;
if (GetGameState()>GAMESTATE_CHARSELECT)
SetNameSpriteState(pNewSpawn,1);
if (GetBodyTypeDesc(BodyType)[0]=='*')
{
WriteChatf("Spawn '%s' has unknown bodytype %d",pNewSpawn->Name,BodyType);
}
CAutoLock Lock(&gPluginCS);
PMQPLUGIN pPlugin=pPlugins;
while(pPlugin)
{
if (pPlugin->AddSpawn)
{
pPlugin->AddSpawn(pNewSpawn);
}
pPlugin=pPlugin->pNext;
}
}
