void Level::Update()
{
background.Update(timer.get_ticks());
if(GameObjects::Instance()->playerShip.isActive)
{
GameObjects::Instance()->playerShip.Update(timer.get_ticks());
}
if(GameObjects::Instance()->PlayerLives != storedLives)
{
lives.Free();
lives.SetText("REST: " + std::to_string(GameObjects::Instance()->PlayerLives));
storedLives = GameObjects::Instance()->PlayerLives;
}
if(GameObjects::Instance()->PlayerScore != storedScore)
{
score.Free();
score.SetText("SCORE: " + std::to_string(GameObjects::Instance()->PlayerScore));
storedScore = GameObjects::Instance()->PlayerScore;
}
HandleCollisions(GameObjects::Instance()->enemies, GameObjects::Instance()->playerShip);
Update(GameObjects::Instance()->enemies, timer.get_ticks());
HandleCollisions(GameObjects::Instance()->projectiles,GameObjects::Instance()->enemies);
Update(GameObjects::Instance()->projectiles,timer.get_ticks());
HandleCollisions(GameObjects::Instance()->enemyProjectiles, GameObjects::Instance()->playerShip);
Update(GameObjects::Instance()->enemyProjectiles,timer.get_ticks());
Update(GameObjects::Instance()->explosions, timer.get_ticks());
objFactory.Update(background.DistanceScrolled());
timer.start();
}
void GameEngine::Frame(float _dt)
{
MovingObject *currentCharacter = NULL;
if (!m_levelStarted)
StartLevel("biglvl"); // In the future there will be some sort of level selection so this call will be moved
// Spawn enemies from pipes
for (std::map<unsigned int, Pipe*>::iterator it = m_listPipes.begin(); it != m_listPipes.end(); ++it)
{
if (it->second->GetPipeType() == SPAWN)
it->second->HandleSpawnEnemies(_dt);
}
for (unsigned int i = 0; i < m_characters.size(); i++)
{
currentCharacter = m_characters[i];
if (currentCharacter != NULL)
{
if (1 / _dt > 20) // No updating at all if framerate < 20 (usually the first few iterations) because it results in inacurrate updating (like Mario drops 300 pixels at beginning of level)
UpdateCharacterPosition(*currentCharacter, _dt);
HandleCollisions(*currentCharacter);
SendCharacterPosition(i);
}
}
DeleteAllDeadCharacters();
}
void GameplayScreen::Update(Game* game)
{
// Immediately return if paused
if (isPaused || isGameOver)
return;
if (isPowerUpState)
{
if (Ghost::CurrentState() != Frightened)
{
// Return to standard background music
isPowerUpState = false;
Mix_PlayMusic(background, -1);
}
}
if (levelManager->GetPlayer()->HasDeathAnimationFinished())
{
// Check if we are out of lives
if (livesRemaining <= 0)
{
fprintf(stdout, "Game Over!\n");
GameEnd(0);
return;
}
else
{
levelManager->ResetAgentPositions();
}
}
// Check for victory condition
if (levelManager->GetPellets().empty())
{
// The level was completed
if (levelManager->LevelCompletedAnimation())
{
// Go to the next level if one exists
if (levelManager->NextLevel() == false)
GameEnd(1);
}
return;
}
levelManager->Update(game->GetDeltaTime());
//// Update the player
//levelManager->GetPlayer()->Update(game->GetDeltaTime());
//// Update the AI
//for (std::vector<Ghost*>::iterator iter = levelManager->GetGhosts().begin();
// iter != levelManager->GetGhosts().end(); ++iter)
//{
// (*iter)->Update(game->GetDeltaTime());
//}
// Handle the collisions last
HandleCollisions();
}
void Update(){
float ticks = (float)SDL_GetTicks() / 1000.0f;
float elapsed = ticks - lastFrameTicks;
lastFrameTicks = ticks;
ball->Update(elapsed);
paddle1->Update(elapsed);
paddle2->Update(elapsed);
if (newGame){
ball->launch();
newGame = false;
}
HandleCollisions();
}
void PlayState::Update(Game &game){
//always set the mouse position
mousePos = sf::Mouse::getPosition(game.window);
if (paused)
pClock.restart();
if (!paused){
//Handle everything
HandleSpawns(game);
HandleUpdates(game);
HandleCollisions(game);
//health & points into string
playerHealth = player1.getHealth();
messageHandler.UpdateStream(healthStream, playerHealth, "pHealthS");
messageHandler.UpdateStream(pointStream, points, "");
}
}
void PhysicsWorld::ExecFrame()
{
LockThread();
//
// [disabled] Lock timestep to improve collision prediction
//m_QueuedTime += (GFloat)rsk::gClock->GetFrameTimeSeconds();
//
// [enabled] Try to normalize the timestep to improve collision prediction
m_FrameTime += (GFloat)rsk::gClock->GetFrameTimeSeconds();
m_FrameTime *= 0.5f;
// if( m_QueuedTime >= m_FrameTime )
{
CheckCollisions();
HandleCollisions();
ApplyGravity();
RSKMAP_ITERATE( m_Entities )
iter->second->ExecFrame( m_FrameTime );
// m_QueuedTime = 0.f;
}
}
bool CTAAirMoveType::Update()
{
float3& pos = owner->pos;
float3& speed = owner->speed;
// This is only set to false after the plane has finished constructing
if (useHeading) {
useHeading = false;
SetState(AIRCRAFT_TAKEOFF);
}
if (owner->stunned || owner->beingBuilt) {
wantedSpeed = ZeroVector;
wantToStop = true;
}
// Allow us to stop if wanted
if (wantToStop) {
ExecuteStop();
}
const float3 lastSpeed = speed;
if (owner->fpsControlPlayer != NULL) {
SetState(AIRCRAFT_FLYING);
const FPSUnitController& con = owner->fpsControlPlayer->fpsController;
const float3 forward = con.viewDir;
const float3 right = forward.cross(UpVector);
const float3 nextPos = pos + speed;
float3 flatForward = forward;
flatForward.y = 0.0f;
flatForward.Normalize();
wantedSpeed = ZeroVector;
if (con.forward) wantedSpeed += flatForward;
if (con.back ) wantedSpeed -= flatForward;
if (con.right ) wantedSpeed += right;
if (con.left ) wantedSpeed -= right;
wantedSpeed.Normalize();
wantedSpeed *= maxSpeed;
if (!nextPos.IsInBounds()) {
speed = ZeroVector;
}
UpdateAirPhysics();
wantedHeading = GetHeadingFromVector(flatForward.x, flatForward.z);
} else {
if (reservedPad) {
CUnit* unit = reservedPad->GetUnit();
const float3 relPos = unit->script->GetPiecePos(reservedPad->GetPiece());
const float3 pos = unit->pos + unit->frontdir * relPos.z
+ unit->updir * relPos.y + unit->rightdir * relPos.x;
if (padStatus == 0) {
if (aircraftState != AIRCRAFT_FLYING && aircraftState != AIRCRAFT_TAKEOFF)
SetState(AIRCRAFT_FLYING);
goalPos = pos;
if (pos.SqDistance2D(owner->pos) < 400*400) {
padStatus = 1;
}
} else if (padStatus == 1) {
if (aircraftState != AIRCRAFT_FLYING) {
SetState(AIRCRAFT_FLYING);
}
flyState = FLY_LANDING;
goalPos = pos;
reservedLandingPos = pos;
wantedHeight = pos.y - ground->GetHeightAboveWater(pos.x, pos.z);
if (owner->pos.SqDistance(pos) < 9 || aircraftState == AIRCRAFT_LANDED) {
padStatus = 2;
}
} else {
if (aircraftState != AIRCRAFT_LANDED)
SetState(AIRCRAFT_LANDED);
owner->pos = pos;
owner->AddBuildPower(unit->unitDef->buildSpeed / 30, unit);
owner->currentFuel = std::min(owner->unitDef->maxFuel,
owner->currentFuel + (owner->unitDef->maxFuel
/ (GAME_SPEED * owner->unitDef->refuelTime)));
if (owner->health >= owner->maxHealth - 1
&& owner->currentFuel >= owner->unitDef->maxFuel) {
airBaseHandler->LeaveLandingPad(reservedPad);
reservedPad = NULL;
padStatus = 0;
goalPos = oldGoalPos;
SetState(AIRCRAFT_TAKEOFF);
}
}
}
// Main state handling
switch (aircraftState) {
case AIRCRAFT_LANDED:
UpdateLanded();
break;
case AIRCRAFT_TAKEOFF:
UpdateTakeoff();
break;
case AIRCRAFT_FLYING:
UpdateFlying();
break;
case AIRCRAFT_LANDING:
UpdateLanding();
break;
case AIRCRAFT_HOVERING:
UpdateHovering();
break;
case AIRCRAFT_CRASHING:
break;
}
}
// Banking requires deltaSpeed.y = 0
deltaSpeed = speed - lastSpeed;
deltaSpeed.y = 0.0f;
// Turn and bank and move; update dirs
UpdateHeading();
UpdateBanking(aircraftState == AIRCRAFT_HOVERING);
owner->UpdateMidPos();
return (HandleCollisions());
}
bool CHoverAirMoveType::Update()
{
const float3 lastPos = owner->pos;
const float4 lastSpd = owner->speed;
AAirMoveType::Update();
if ((owner->IsStunned() && !owner->IsCrashing()) || owner->beingBuilt) {
wantedSpeed = ZeroVector;
UpdateAirPhysics();
return (HandleCollisions(collide && !owner->beingBuilt && (padStatus == PAD_STATUS_FLYING) && (aircraftState != AIRCRAFT_TAKEOFF)));
}
// allow us to stop if wanted (changes aircraft state)
if (wantToStop)
ExecuteStop();
if (aircraftState != AIRCRAFT_CRASHING) {
if (owner->UnderFirstPersonControl()) {
SetState(AIRCRAFT_FLYING);
const FPSUnitController& con = owner->fpsControlPlayer->fpsController;
const float3 forward = con.viewDir;
const float3 right = forward.cross(UpVector);
const float3 nextPos = lastPos + owner->speed;
float3 flatForward = forward;
flatForward.Normalize2D();
wantedSpeed = ZeroVector;
if (con.forward) wantedSpeed += flatForward;
if (con.back ) wantedSpeed -= flatForward;
if (con.right ) wantedSpeed += right;
if (con.left ) wantedSpeed -= right;
wantedSpeed.Normalize();
wantedSpeed *= maxSpeed;
if (!nextPos.IsInBounds()) {
owner->SetVelocityAndSpeed(ZeroVector);
}
UpdateAirPhysics();
wantedHeading = GetHeadingFromVector(flatForward.x, flatForward.z);
}
if (reservedPad != NULL) {
MoveToRepairPad();
if (padStatus >= PAD_STATUS_LANDING) {
flyState = FLY_LANDING;
}
}
}
switch (aircraftState) {
case AIRCRAFT_LANDED:
UpdateLanded();
break;
case AIRCRAFT_TAKEOFF:
UpdateTakeoff();
break;
case AIRCRAFT_FLYING:
UpdateFlying();
break;
case AIRCRAFT_LANDING:
UpdateLanding();
break;
case AIRCRAFT_HOVERING:
UpdateHovering();
break;
case AIRCRAFT_CRASHING: {
UpdateAirPhysics();
if ((CGround::GetHeightAboveWater(owner->pos.x, owner->pos.z) + 5.0f + owner->radius) > owner->pos.y) {
owner->ClearPhysicalStateBit(CSolidObject::PSTATE_BIT_CRASHING);
owner->KillUnit(NULL, true, false);
} else {
#define SPIN_DIR(o) ((o->id & 1) * 2 - 1)
wantedHeading = GetHeadingFromVector(owner->rightdir.x * SPIN_DIR(owner), owner->rightdir.z * SPIN_DIR(owner));
wantedHeight = 0.0f;
#undef SPIN_DIR
}
new CSmokeProjectile(owner, owner->midPos, gs->randVector() * 0.08f, 100 + gs->randFloat() * 50, 5, 0.2f, 0.4f);
} break;
}
if (lastSpd == ZeroVector && owner->speed != ZeroVector) { owner->script->StartMoving(false); }
if (lastSpd != ZeroVector && owner->speed == ZeroVector) { owner->script->StopMoving(); }
// Banking requires deltaSpeed.y = 0
deltaSpeed = owner->speed - lastSpd;
deltaSpeed.y = 0.0f;
// Turn and bank and move; update dirs
UpdateHeading();
UpdateBanking(aircraftState == AIRCRAFT_HOVERING);
return (HandleCollisions(collide && !owner->beingBuilt && (padStatus == PAD_STATUS_FLYING) && (aircraftState != AIRCRAFT_TAKEOFF)));
}
void CLevel::Update(CTime elapsedTime)
{
mPlayer.Update(elapsedTime);
HandleCollisions();
}
bool CHoverAirMoveType::Update()
{
float3& pos = owner->pos;
float3& speed = owner->speed;
AAirMoveType::Update();
if (owner->stunned || owner->beingBuilt) {
wantedSpeed = ZeroVector;
wantToStop = true;
}
// Allow us to stop if wanted
if (wantToStop) {
ExecuteStop();
}
const float3 lastSpeed = speed;
if (owner->fpsControlPlayer != NULL) {
SetState(AIRCRAFT_FLYING);
const FPSUnitController& con = owner->fpsControlPlayer->fpsController;
const float3 forward = con.viewDir;
const float3 right = forward.cross(UpVector);
const float3 nextPos = pos + speed;
float3 flatForward = forward;
flatForward.y = 0.0f;
flatForward.Normalize();
wantedSpeed = ZeroVector;
if (con.forward) wantedSpeed += flatForward;
if (con.back ) wantedSpeed -= flatForward;
if (con.right ) wantedSpeed += right;
if (con.left ) wantedSpeed -= right;
wantedSpeed.Normalize();
wantedSpeed *= maxSpeed;
if (!nextPos.IsInBounds()) {
speed = ZeroVector;
}
UpdateAirPhysics();
wantedHeading = GetHeadingFromVector(flatForward.x, flatForward.z);
} else {
if (reservedPad != NULL) {
MoveToRepairPad();
if (padStatus >= 1) {
flyState = FLY_LANDING;
}
}
// Main state handling
switch (aircraftState) {
case AIRCRAFT_LANDED:
UpdateLanded();
break;
case AIRCRAFT_TAKEOFF:
UpdateTakeoff();
break;
case AIRCRAFT_FLYING:
UpdateFlying();
break;
case AIRCRAFT_LANDING:
UpdateLanding();
break;
case AIRCRAFT_HOVERING:
UpdateHovering();
break;
case AIRCRAFT_CRASHING:
break;
}
}
// Banking requires deltaSpeed.y = 0
deltaSpeed = speed - lastSpeed;
deltaSpeed.y = 0.0f;
// Turn and bank and move; update dirs
UpdateHeading();
UpdateBanking(aircraftState == AIRCRAFT_HOVERING);
return (HandleCollisions());
}
