void NcursesUI::draw(IGame const &game)
{
int color = 0;
erase();
// Draw background
for (int x = _gameSize.first - 1; x >= 0; --x)
for (int y = _gameSize.second - 1; y >= 0; --y)
_drawChunk(x, y, (color = (x + y) % 3) + 13, '.');
// Draw blocks
for (auto *b : game.getBlocks())
_drawChunk(b->getX(), b->getY(), 20 + b->getType(), '+' + b->getType());
// Draw snake
for (auto &c : game.getSnake().getChunks())
_drawChunk(c.first, c.second, 2, 'X');
if (game.getSnake().isDie())
{
auto &head = *(game.getSnake().getChunks().begin());
_drawChunk(head.first, head.second, 3, 'x');
}
attron(COLOR_PAIR(1));
move(0, 0);
printw("Score: %-3d Time: %-3d Length: %-3d FPS: %d",
game.getScore(), game.getPlayTime(),
game.getSnake().getChunks().size(), game.getFPS());
if (game.getSnake().isDie())
printw(" [[ DIE ]]");
else if (game.isPaused())
printw(" [[ PAUSE ]]");
refresh();
}
void FakeArtificialIntelligence::idle(IGame &game)
{
double px=game.getPacman()->X();
double py=game.getPacman()->Y();
for(unsigned int c=0;c<game.getGhosts().size();c++)
{
IGhost *g=game.getGhosts().at(c);
double gx=g->X();
double gy=g->Y();
if(py==gy) py-=0.1;
double r=(px-gx)/(py-gy);
if(r>1||r<-1)
{
if(px<gx)
{
g->setDirection(-1,0);
}
else
{
g->setDirection(1,0);
}
}
else
{
if(py<gy)
{
g->setDirection(0,-1);
}
else
{
g->setDirection(0,1);
}
}
}
}
void CGameRealtimeRemoteUpdateListener::CameraSync()
{
IGame *pGame = gEnv->pGame;
if(!pGame)
return;
IGameFramework *pGameFramework=pGame->GetIGameFramework();
if(!pGameFramework)
return;
IViewSystem *pViewSystem=pGameFramework->GetIViewSystem();
if(!pViewSystem)
return;
IView *pView=pViewSystem->GetActiveView();
if(!pView)
return;
IEntity *pEntity = gEnv->pEntitySystem->GetEntity(pView->GetLinkedId());
if(!pEntity)
return;
IActor *pPlayer=pGameFramework->GetClientActor();
if ( !pPlayer )
return;
IEntity * pPlayerEntity = pPlayer->GetEntity();
if (!pPlayerEntity)
return;
IPhysicalEntity * piPlayerPhysics = pPlayerEntity->GetPhysics();
if ( !piPlayerPhysics )
return;
pe_player_dimensions dim;
piPlayerPhysics->GetParams( &dim );
//TODO: only GDCE2011, in the future make this game magic constant be gone in LiveCreate 2.0
// game player view code has a complex position code path, the sync position should be
// honoured by game code when live creaate camera sync is enabled
m_Position.z -= 1.62f;
pEntity->SetPos(m_Position);
pPlayerEntity->Hide(false);
pViewSystem->SetOverrideCameraRotation(true,Quat::CreateRotationVDir(m_ViewDirection));
pPlayerEntity->Hide(true);
SEntityUpdateContext ctx;
pPlayer->Update( ctx, 0 );
m_bCameraSync = true;
}
//--------------------------------------------------------------------------------------------------
// Name: IsEntity3rdPerson
// Desc: Returns 3rd person state
//--------------------------------------------------------------------------------------------------
bool CGameEffect::IsEntity3rdPerson(EntityId entityId)
{
bool bIs3rdPerson = true;
IGame* pGame = gEnv->pGame;
if(pGame)
{
IGameFramework* pGameFramework = pGame->GetIGameFramework();
if(pGameFramework)
{
EntityId clientEntityId = pGameFramework->GetClientActorId();
if(clientEntityId == entityId)
{
bIs3rdPerson = pGameFramework->GetClientActor()->IsThirdPerson();
}
}
}
return bIs3rdPerson;
}//-------------------------------------------------------------------------------------------------
void CGameRealtimeRemoteUpdateListener::EndCameraSync()
{
IGame *pGame = gEnv->pGame;
if(!pGame)
return;
IGameFramework *pGameFramework=pGame->GetIGameFramework();
if(!pGameFramework)
return;
IViewSystem *pViewSystem=pGameFramework->GetIViewSystem();
if(!pViewSystem)
return;
IView *pView=pViewSystem->GetActiveView();
if(!pView)
return;
IEntity *pEntity = gEnv->pEntitySystem->GetEntity(pView->GetLinkedId());
if(!pEntity)
return;
CPlayer *pPlayer=static_cast<CPlayer *>(pGameFramework->GetClientActor());
if (!pPlayer)
return;
IEntity * pPlayerEntity = pPlayer->GetEntity();
if ( !pPlayerEntity )
return;
#ifndef _RELEASE
pPlayer->SetFlyMode(m_nPreviousFlyMode);
#endif
pPlayerEntity->Hide(false);
pViewSystem->SetOverrideCameraRotation(false,Quat::CreateRotationVDir(m_ViewDirection));
pEntity->SetRotation(Quat::CreateRotationVDir(m_ViewDirection));
m_bCameraSync = false;
// reset our head-position delta on end camera sync
m_headPositionDelta.zero();
}
void Map::setup(IGame &game, int cols, int rows, int width, int height)
{
this->c=cols;
this->r=rows;
this->w=width;
this->h=height;
m.clear();
m.resize(cols,vector<int>(rows,0));
// Changed for use a same seed
//srand(time(NULL));
mapgen();
game.getPacman()->X((cols/2+0.5)*width);
game.getPacman()->Y(1.5*height);
game.getPacman()->speed(width*3.0);
unsigned int c=0;
for(int j=-2;j<=0;j++)
for(int i=-2;i<=2;i++)
if(c<game.getGhosts().size())
{
IGhost *g=game.getGhosts().at(c);
// ghost's speed is dynamic
//g->speed(game.getPacman()->speed()*1.5);
g->X((cols/2+i+0.5)*width);
g->Y((rows/2+j+0.5)*height);
c++;
}
game.reshape(0,0);
}
void OpenGLUI::_putTexts(IGame const &game)
{
int const fontSize(_winSize.first / 19);
double const padding(static_cast<double>(_winSize.first) / 19.);
double const timeWidth(static_cast<double>(_winSize.first) / 19. * 8.);
double const pausePadding(
(static_cast<double>(_winSize.first) -
static_cast<double>(_winSize.first) / 19. * 4.) / 2.);
this->_font.FaceSize(fontSize);
this->_font.Render(
(std::string("Score: ") += std::to_string(game.getScore())).c_str(),
-1, FTPoint(padding, padding));
this->_font.Render(
(std::string("Played: ")
+= std::to_string(game.getPlayTime() / 60)
+= std::string(":")
+= std::string(game.getPlayTime() % 60 > 9 ? "" : "0")
+= std::to_string(game.getPlayTime() % 60)).c_str(),
-1, FTPoint(static_cast<double>(_winSize.first) - timeWidth - padding,
padding));
if (game.getSnake().isDie())
{
this->_font.Render(
std::string("Death!!").c_str(), -1,
FTPoint(pausePadding, static_cast<double>(_winSize.second) / 2.));
}
else if (game.isPaused())
{
this->_font.Render(
std::string("Paused").c_str(), -1,
FTPoint(pausePadding, static_cast<double>(_winSize.second) / 2.));
}
return ;
}
void CGameRealtimeRemoteUpdateListener::EndCameraSync()
{
IGame *pGame = gEnv->pGame;
if(!pGame)
return;
IGameFramework *pGameFramework=pGame->GetIGameFramework();
if(!pGameFramework)
return;
IViewSystem *pViewSystem=pGameFramework->GetIViewSystem();
if(!pViewSystem)
return;
IView *pView=pViewSystem->GetActiveView();
if(!pView)
return;
IEntity *pEntity = gEnv->pEntitySystem->GetEntity(pView->GetLinkedId());
if(!pEntity)
return;
IActor *pPlayer=pGameFramework->GetClientActor();
if (!pPlayer)
return;
IEntity * pPlayerEntity = pPlayer->GetEntity();
if ( !pPlayerEntity )
return;
SEntityUpdateContext ctx;
pPlayer->Update( ctx, 0 );
pPlayerEntity->Hide(false);
pViewSystem->SetOverrideCameraRotation(false,Quat::CreateRotationVDir(m_ViewDirection));
pEntity->SetRotation(Quat::CreateRotationVDir(m_ViewDirection));
m_bCameraSync = false;
// reset our head-position delta on end camera sync
m_headPositionDelta.zero();
}
//--------------------------------------------------------------------------------------------------
// Name: Update
// Desc: Updates effects system and any effects registered in it's update list
//--------------------------------------------------------------------------------------------------
void GameSDKCGameEffectsSystem::Update(float frameTime)
{
FX_ASSERT_MESSAGE(m_isInitialised,"Game Effects System trying to update without being initialised");
// Get pause state
bool isPaused = false;
IGame* pGame = gEnv->pGame;
if(pGame)
{
IGameFramework* pGameFramework = pGame->GetIGameFramework();
if(pGameFramework)
{
isPaused = pGameFramework->IsGamePaused();
}
}
// Update effects
if(m_effectsToUpdate)
{
GameSDKIGameEffect* effect = m_effectsToUpdate;
while(effect)
{
m_nextEffectToUpdate = effect->Next();
if((!isPaused) || (effect->IsFlagSet(GAME_EFFECT_UPDATE_WHEN_PAUSED)))
{
SOFTCODE_RETRY(effect,effect->Update(frameTime));
}
effect = m_nextEffectToUpdate;
}
}
m_nextEffectToUpdate = NULL;
#if DEBUG_GAME_FX_SYSTEM
DrawDebugDisplay();
#endif
}//-------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------
// Main function
//-----------------------------------------------------------------
int main (int argc, char* argv[])
{
//instanciante the game
IGame *pGame = new Game;
//get the game engine
GameEngine *pGameEngine = GameEngine::GetEngine();
static int iTickTrigger = 0;
int iTickCount;
bool done = false;
const char* game_name = "Game skeleton";
const char* game_icon = "res/Skeleton.ico";
//Initialize or quit if an error occured
if (!pGameEngine->Initialize(game_name, game_icon) ||
!pGame->Initialize()){
std::cout << "INIT ERR" << std::endl;
return EXIT_FAILURE;
}
//start the game now
pGameEngine->SetSleep(false);
pGame->Start();
// Enter the main message loop
while (!done) {
// Make sure the game engine isn't sleeping
if (!pGameEngine->GetSleep()){
// Check the tick count to see if a game cycle has elapsed
iTickCount = SDL_GetTicks();
if (iTickCount > iTickTrigger){
iTickTrigger = iTickCount +
pGameEngine->GetFrameDelay();
pGame->Cycle();
}
}
pGameEngine->HandleEvent();
// Paint the game
pGame->Paint();
}
// End the game
pGame->End();
return EXIT_SUCCESS;
}
void CGameRealtimeRemoteUpdateListener::CameraSync()
{
IGame *pGame = gEnv->pGame;
if(!pGame)
return;
IGameFramework *pGameFramework=pGame->GetIGameFramework();
if(!pGameFramework)
return;
IViewSystem *pViewSystem=pGameFramework->GetIViewSystem();
if(!pViewSystem)
return;
IView *pView=pViewSystem->GetActiveView();
if(!pView)
return;
IEntity *pEntity = gEnv->pEntitySystem->GetEntity(pView->GetLinkedId());
if(!pEntity)
return;
CPlayer *pPlayer=static_cast<CPlayer *>(pGameFramework->GetClientActor());
if ( !pPlayer )
return;
IEntity * pPlayerEntity = pPlayer->GetEntity();
if (!pPlayerEntity)
return;
IPhysicalEntity * piPlayerPhysics = pPlayerEntity->GetPhysics();
if ( !piPlayerPhysics )
return;
pe_player_dimensions dim;
piPlayerPhysics->GetParams( &dim );
// if delta from head to center of character is zero, then we need to recompute it
if( m_headPositionDelta.GetLength() == 0 )
{
Vec3 camPos = pViewSystem->GetActiveView()->GetCurrentParams()->position;
const Vec3& entPos = pEntity->GetPos();
m_headPositionDelta = camPos - entPos;
}
// offset the camera position by the current delta to put the head eye position to center of character
m_Position -= m_headPositionDelta;
pPlayerEntity->Hide(false);
pEntity->SetPos(m_Position);
pViewSystem->SetOverrideCameraRotation(true,Quat::CreateRotationVDir(m_ViewDirection));
#ifndef _RELEASE
if ( m_bCameraSync == false && m_nPreviousFlyMode != eCameraModes_fly_mode_noclip )
{
m_nPreviousFlyMode=pPlayer->GetFlyMode();
pPlayer->SetFlyMode(eCameraModes_fly_mode_noclip);
}
#endif
pPlayerEntity->Hide(true);
m_bCameraSync = true;
}
void PlayerMove(int playerId, IGame* game, Move& move, bool& bomb)
{
XGAME = game;
GetChainMatrix();
// fprintf(out,"Turn: %d\n", turn );
// fflush(out);
//simulation->BeginTurn(game);
++turn;
move = moveNone;
float m = -1000;
int gata = 0;
int killswitch = 0;
vector < int > bmbs;
memset(heatmap, 0, sizeof(heatmap));
for (int i = 0; i < game->PlayerCount(); ++ i)
if(game->PlayerAlive(i) && i!=playerId)
{
IGame * ngame = game->Clone();
int &x = ngame->Bomb(ngame->PlayerPosX(i), ngame->PlayerPosY(i));
x = 7;
simulation->BeginTurn(ngame);
simulation->EndTurn(ngame);
memset(v2, 0, sizeof(v2));
float f1 = dfs(ngame, i, 6, 0);
delete ngame;
/* ngame = game->Clone();
simulation->BeginTurn(ngame);
simulation->EndTurn(ngame);
memset(v2, 0, sizeof(v2));
float f2 = dfs (ngame, i, 6, 0);*/
if (!(f1 <= 0.001))
{
bmbs.push_back(i);
}
//delete ngame;
}
for (int we = 6; we >=0; we-=6)
{
for (int i = 0; i < bmbs.size(); ++ i)
{
int &x = game->Bomb(game->PlayerPosX(bmbs[i]), game->PlayerPosY(bmbs[i]));
x = we;
}
generate_heat_map(game, playerId);
for (int k = 1; k >= 0 && !gata; --k)
for (Move i = moveUp; i <= moveCount; ++i)
{
if (k == 0 && m > 0)
{
gata = 1;
break;
}
if (i == moveCount)
i = moveNone;
if (simulation->CanMove(game, playerId, i) || game->Bomb(game->PlayerPosX(playerId)+my[i],game->PlayerPosY(playerId)+mx[i]) == -1)
{
IGame * ngame = game->Clone();
simulation->StoreMove(playerId, i, k);
/*
for (int h = 0; h < game->PlayerCount(); ++h)
if (h!=playerId)
simulation->StoreMove(h, moveNone, true);
*/
simulation->BeginTurn(ngame);
simulation->EndTurn(ngame);
if (ngame->PlayerAlive(playerId))
{
float o;
memset(v2, 0, sizeof(v2));
o = dfs(ngame, playerId, 8, i);
if (o > m)
{
m = o;
move = i;
bomb = k;
}
}
delete ngame;
//delete ngame;
}
if (i == moveNone)
break;
}
if (m <= 0.001)
{
printf("I can't survive\n");
}
else
break;
}
printf("Time left %d\n", GetTimeLeft());
//TODO: add AI code here
//TODO: assign values to move and bomb (which represent your move for this step)
//HINT: this function is called once for every game step
//HINT: you can use the simulation pointer to simulate game states
//HINT: you can modify the contents of the game pointer
//HINT: you can clone the game state to evolve different scenarios
//HINT: this function must return before GetTimeLeft() returns 0
//HINT: the game will evolve 1 step before your character starts moving, so it's useful to
// call simulation->BeginTurn(game) to get the state of the game at the time your player
// will begin to move or place the bomb.
}
