bool Animation::NextSheet() { if ((curr_sheetnum + 1) != sheets.size()) { curr_sheetnum++; RefreshSheet(); CheckCollisions(); } else { if (curr_beat >= sheets.at(curr_sheetnum).GetNumBeats()) { if (sheets.at(curr_sheetnum).GetNumBeats() == 0) { curr_beat = 0; } else { curr_beat = sheets.at(curr_sheetnum).GetNumBeats()-1; } } return false; } return true; }
void GameplayState::Update(StateEngine* state, double dt) { characters[DAVE]->Update(dt); characters[MANDY]->Update(dt); if (!m_isThrowing) characters[NIGEL]->Update(dt); ScrollCranes(dt); CheckInterations(state); for (int i = 0; i <3; i++) { CheckObjects(i); CheckCollisions(i); } m_Cam->SetPosition( CIwSVec2(static_cast<int16>(-characters[m_CharacterIndex]->GetPosition().x + (screenWidth /2)), static_cast<int16>(-characters[m_CharacterIndex]->GetPosition().y + (screenHeight - characters[m_CharacterIndex]->GetHeight() - 32)))); if (s3eKeyboardGetState(s3eKeySpace) == 4) m_SpacePressed = false; if (s3ePointerGetState(S3E_POINTER_BUTTON_LEFTMOUSE) == 4) { m_MouseClicked = false; m_ClickLocation = CIwFVec2(0,0); m_TerminalSound->ResetCounter(); } }
vec3 Player::MoveAbsolute(vec3 direction, const float speed, bool shouldChangeForward) { if (shouldChangeForward) { m_forward = normalize(direction); } m_targetForward = m_forward; m_targetForward.y = 0.0f; m_targetForward = normalize(m_targetForward); vec3 totalAmountMoved; vec3 movement = direction; vec3 movementAmount = direction*speed; vec3 pNormal; int numberDivision = 1; while (length(movementAmount) >= 1.0f) { numberDivision++; movementAmount = direction*(speed / numberDivision); } for (int i = 0; i < numberDivision; i++) { float speedToUse = (speed / numberDivision) + ((speed / numberDivision) * i); vec3 posToCheck = GetCenter() + movement*speedToUse; if (m_bDoStepUpAnimation == false) { bool stepUp = false; if (CheckCollisions(posToCheck, m_previousPosition, &pNormal, &movement, &stepUp)) { if (stepUp) { if (m_bDoStepUpAnimation == false) { m_bDoStepUpAnimation = true; m_stepUpAnimationYAmount = 0.0f; m_stepUpAnimationPrevious = 0.0f; m_stepUpAnimationYOffset = 0.0f; Interpolator::GetInstance()->AddFloatInterpolation(&m_stepUpAnimationYAmount, 0.0f, (Chunk::BLOCK_RENDER_SIZE*2.2f), 0.1f, 0.0f, NULL, _StepUpAnimationFinished, this); Interpolator::GetInstance()->AddFloatInterpolation(&m_stepUpAnimationYOffset, (Chunk::BLOCK_RENDER_SIZE*2.2f), 0.0f, 0.2f, -100.0f); } } } } m_position += (movement * speedToUse); totalAmountMoved += (movement * speedToUse); } // Change to run animation m_pVoxelCharacter->BlendIntoAnimation(AnimationSections_FullBody, true, AnimationSections_FullBody, "Run", 0.01f); m_bIsIdle = false; return totalAmountMoved; }
/** * @brief CollisionSystem::Update checks for collisions between entities that have moved and all other entities * @param dt frame time */ void CollisionSystem::Update(sf::Time dt) { PositionComponent* p1 = nullptr; sf::Vector2f norm; std::list<unsigned int> movedEntities = _MovedEntities; _MovedEntities.clear(); std::list<unsigned int>::iterator mit; FillBins(); for(mit = movedEntities.begin(); mit != movedEntities.end(); mit++) { p1 = this->GetEntity(*mit)->GetComponent<PositionComponent>("Position"); if(CheckCollisions(*mit, norm)) { MoveEntityMessage msg; msg.ID = *mit; msg.newPosition.x = p1->GetPosition().x - norm.x; msg.newPosition.y = p1->GetPosition().y - norm.y; Emit<MoveEntityMessage>(msg); } } ClearBins(); }
void CStuff::Update() { m_pPlayer->Update(); camera->x = m_pPlayer->GetX() - ((float)camera->w / 2); camera->y = m_pPlayer->GetY() - ((float)camera->h / 2); if (camera->x < 0) camera->x = 0; if (camera->y < 0) camera->y = 0; if (camera->x > level_width - camera->w) camera->x = level_width - camera->w; if (camera->y > level_height - camera->h) camera->y = level_height - camera->h; g_pDebugscreen->Set("cameraX:", camera->x); g_pDebugscreen->Set("cameraY:", camera->y); m_pPlayer->Render(camera->x, camera->y); m_pPlayer->LifeRender(); list<CExplosion>::iterator ItEx = m_ExplosionList.begin(); while (ItEx != m_ExplosionList.end()) if (ItEx->IsAlive()) ItEx++; else ItEx = m_ExplosionList.erase(ItEx); CommandSpawns(); CheckCollisions(); RenderMonsters(); }
bool Animation::PrevBeat() { unsigned i; if (curr_beat == 0) { if (curr_sheetnum == 0) return false; curr_sheetnum--; for (i = 0; i < numpts; i++) { curr_cmds[i] = sheets.at(curr_sheetnum).commands[i].end() - 1; EndCmd(i); } curr_beat = sheets.at(curr_sheetnum).GetNumBeats(); } for (i = 0; i < numpts; i++) { if (!(*curr_cmds.at(i))->PrevBeat(pts[i])) { // Advance to prev command, skipping zero beat commands if (curr_cmds[i] != sheets.at(curr_sheetnum).commands[i].begin()) { --curr_cmds[i]; EndCmd(i); // Set to next-to-last beat of this command // Should always return true (*curr_cmds[i])->PrevBeat(pts[i]); } } } if (curr_beat > 0) curr_beat--; CheckCollisions(); return true; }
void Brick::Update(Ball* ball) { if (!bDestroyed) { CheckCollisions(ball); } }
void MyBOManager::Update(void) { for (uint nObject = 0; nObject < m_nObjectCount; nObject++) { m_llCollidingIndices[nObject].clear(); } CheckCollisions(); }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Update(): // // Returns: Void // // Mod. Name: Ethan Pendergraft // Mod. Date: 6/2/2012 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void CComponent_IntakePipeCollision::Update( float fDT ) { // We only need to check collisions if // the pipe is corkable if( m_pParent ) { // Set the collision object // to the parent's collision object if( !m_pCollisionObject ) { m_pCollisionObject = (AABB*)m_pParent->GetCollidableObject(); } } // only move the plug // if we aren't plugged yet if( m_bIsGettingCorked ) { MoveCork( fDT ); } vec3f NewCenter = m_pParent->GetWorldMat()->axis_pos; m_abTarget.SetWorldPoint (NewCenter); ((AABB*)m_pParent->GetCollidableObject())->SetWorldPoint (NewCenter); CheckCollisions( fDT ); // don't check for the cork // if you can't cork this pipe if( !m_bCorkable ) { return; } CheckCorkableAABB( fDT ); //D3DXMATRIX mat; //D3DXMatrixIdentity (&mat); //mat._41 = m_abTarget.GetMax2DTransformed().x; //mat._42 = m_abTarget.GetMax2DTransformed().y; //mat._43 = -300.0f; //DebugShapes::RenderSphere (mat); //mat._41 = m_abTarget.GetMin2DTransformed().x; //mat._42 = m_abTarget.GetMin2DTransformed().y; //mat._43 = -300.0f; //DebugShapes::RenderSphere (mat); // We only need to check collisions if // the pipe is corkable }
bool CKinematics2DEngine::CollisionsDetection( const CKinematics2DCollisionRectangle* pc_rectangle ) { if(!m_bDetectCollisions) return false; bool enabled = pc_rectangle->IsEnabled(); for( TKinematics2DEntityMap::const_iterator it = m_tPhysicsEntities.begin(); it != m_tPhysicsEntities.end(); ++it ) { /* don't ckeck if it's the same entity */ if( pc_rectangle == it->second ) continue; bool it_enabled = it->second->IsEnabled(); TKinematics2DCollisionType it_type = it->second->GetCollisionType(); // skip collision detection if both entities are disabled or if // one of them has no collision model if( (!it_enabled && !enabled) || (it_type == KINEMATICS2D_COLLISION_NONE) ) { continue; } // check intersection between bounding boxes if( !pc_rectangle->GetEmbodiedEntity().GetBoundingBox().Intersects( it->second->GetEmbodiedEntity().GetBoundingBox() ) ) { continue; } bool collision_detected = false; if( it_type == KINEMATICS2D_COLLISION_CIRCLE ) { collision_detected = CheckCollisions(dynamic_cast<CKinematics2DCollisionCircle*>(it->second), pc_rectangle); } else if( it_type == KINEMATICS2D_COLLISION_RECTANGLE ) { collision_detected = CheckCollisions(pc_rectangle, dynamic_cast<CKinematics2DCollisionRectangle*>(it->second)); } else { continue; } /* reset to previous positions if collision is detected */ if( collision_detected ) { return true; } } return false; }
bool Animation::PrevSheet() { if (curr_beat == 0) { if (curr_sheetnum > 0) { curr_sheetnum--; } } RefreshSheet(); CheckCollisions(); return true; }
/** *Advances our block to the next rotation state */ void BlockEntity::AdvanceState() { mState = (mState + 1) % STATES; lastDirection = "Rotate"; if (!CheckCollisions().empty()) { GetSector()->As<SectorTetromino>()->mUndoRotate = true; } else { GetSector()->As<SectorTetromino>()->mPlayRotate = true; } }
void Player::Update(const Camera& camera, float dt) { Applyforces(dt); Move(dt); mSelf->Update(camera, dt); //triming the AABB mSelf->mMeshBox.Extents.z = 5.0f; // Makes the Dude a bit wider then 0 to prevent Z fighting .. mSelf->mMeshBox.Extents.x -= 23.0f; //mSelf->mMeshBox.Extents.y -= 1.0f; CheckCollisions(); if (mItemDescription){ mItemDescription->Update(camera, dt); if (mItemDescription->mDead){ mItemDescription = nullptr; } } }
/** * @brief CollisionSystem::ValidateEntity validates an entity to update * @param ID the entity to validate */ bool CollisionSystem::ValidateEntity(unsigned int ID) { Entity* e = this->GetEntity(ID); sf::Vector2f norm; if(CheckCollisions(ID, norm)) { DestroyEntityMessage dmsg; dmsg.ID = ID; Emit<DestroyEntityMessage>(dmsg); return false; } return e->HasComponent("Collider") && e->HasComponent("Position"); }
// Movement void Player::MoveAbsolute(vec3 direction, const float speed, bool shouldChangeForward) { if (dot(direction, m_movementVelocity) > -0.9f) { direction = normalize(direction + (m_movementVelocity*0.4f)); } if (shouldChangeForward) { m_forward = (length(m_movementVelocity) > 0.01f) ? m_movementVelocity : direction; m_forward = normalize(m_forward); } m_targetForward = m_forward; m_targetForward.y = 0.0f; m_targetForward = normalize(m_targetForward); vec3 movement = direction; vec3 movementAmount = direction*speed; vec3 pNormal; int numberDivision = 1; while (length(movementAmount) >= 1.0f) { numberDivision++; movementAmount = direction*(speed / numberDivision); } for (int i = 0; i < numberDivision; i++) { float speedToUse = (speed / numberDivision) + ((speed / numberDivision) * i); vec3 posToCheck = GetCenter() + movement*speedToUse; if (CheckCollisions(posToCheck, m_previousPosition, &pNormal, &movement)) { } m_position += (movement * speedToUse)*0.95f; } m_movementVelocity += (direction * speed) * 0.85f; // Change to run animation if (m_pVoxelCharacter->HasAnimationFinished(AnimationSections_FullBody)) { m_pVoxelCharacter->BlendIntoAnimation(AnimationSections_FullBody, false, AnimationSections_FullBody, "Run", 0.01f); } m_bIsIdle = false; }
void MyBOManager::CheckCollisions(MyOctant &octant) { if (useOctree) { uint numChildren = octant.GetNumChildren(); if (numChildren > 0) { for (int i = 0; i < numChildren; i++) CheckCollisions(octant.m_pChildren[i]); } else { std::vector<int> octantObjList = octant.GetObjIndexList(); if (octantObjList.size() < 2) return; for (uint i = 0; i < octantObjList.size() - 1; i++) { for (uint c = i + 1; c < octantObjList.size(); c++) { int obj1 = octantObjList[i]; int obj2 = octantObjList[c]; if (m_lObject[obj1]->IsColliding(m_lObject[obj2])) { m_llCollidingIndices[obj1].push_back(obj2); m_llCollidingIndices[obj2].push_back(obj1); } } } } } else { for (uint i = 0; i < m_nObjectCount - 1; i++) { for (uint c = i + 1; c < m_nObjectCount; c++) { if (m_lObject[i]->IsColliding(m_lObject[c])) { m_llCollidingIndices[i].push_back(c); m_llCollidingIndices[c].push_back(i); } } } } }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Function Name: Update() // Purpose: Update all data members // Original Author: Rueben Massey // Creation Date: 6/4/2012 // Last Modification By: // Last Modification Date: ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void CComponent_OutletCollision::Update( float fDT ) { if( m_pParent ) { // Set the collision object // to the parent's collision object if( !m_pCollisionObject ) { m_pCollisionObject = (AABB*)m_pParent->GetCollidableObject(); } } // only move the plug // if we aren't plugged yet if( m_bIsGettingPlugged ) { MovePlug( fDT ); } vec3f NewCenter = m_pParent->GetWorldMat()->axis_pos; m_OutletAABB.SetWorldPoint (NewCenter); ((AABB*)m_pParent->GetCollidableObject())->SetWorldPoint (NewCenter); /*D3DXMATRIX mat; mat._41 = m_OutletAABB.GetMax2DTransformed().x; mat._42 = m_OutletAABB.GetMax2DTransformed().y; mat._43 = -600.0f; DebugShapes::RenderSphere (mat); mat._41 = m_OutletAABB.GetMin2DTransformed().x; mat._42 = m_OutletAABB.GetMin2DTransformed().y; mat._43 = -600.0f; DebugShapes::RenderSphere (mat); mat._41 = m_OutletAABB.GetMin2DTransformed().x; mat._42 = m_OutletAABB.GetMax2DTransformed().y; mat._43 = -600.0f; DebugShapes::RenderSphere (mat); mat._41 = m_OutletAABB.GetMax2DTransformed().x; mat._42 = m_OutletAABB.GetMin2DTransformed().y; mat._43 = -600.0f; DebugShapes::RenderSphere (mat);*/ CheckPlugCollisions( fDT ); CheckCollisions( fDT ); }
void Agent::Update(float a_deltaTime) { // Update the velocity with the current acceleration m_movementInfo.m_velocityX += m_movementInfo.m_accelerationX; m_movementInfo.m_velocityY += m_movementInfo.m_accelerationY; // constrain the velocity if (m_movementInfo.m_velocityX > m_movementInfo.m_maxSpeed) { m_movementInfo.m_velocityX = m_movementInfo.m_maxSpeed; } else if (m_movementInfo.m_velocityX < -m_movementInfo.m_maxSpeed) { m_movementInfo.m_velocityX = -m_movementInfo.m_maxSpeed; } if (m_movementInfo.m_velocityY > m_movementInfo.m_maxSpeed) { m_movementInfo.m_velocityY = m_movementInfo.m_maxSpeed; } else if (m_movementInfo.m_velocityY < -m_movementInfo.m_maxSpeed) { m_movementInfo.m_velocityY = -m_movementInfo.m_maxSpeed; } // set rotation m_movementInfo.m_rotation = atan2(m_movementInfo.m_velocityY, m_movementInfo.m_velocityX) + (float)M_PI / 2.0f; // reset the acceleration for the next frame m_movementInfo.m_accelerationX = 0.0f; m_movementInfo.m_accelerationY = 0.0f; // add the velocity to the position m_movementInfo.m_positionX += m_movementInfo.m_velocityX; m_movementInfo.m_positionY += m_movementInfo.m_velocityY; CheckCollisions(); switch (GetColour()) { case Colour::Green: Patrol(); break; case Colour::Blue: Health(); break; case Colour::Red: Attack(); break; case Colour::Orange: Search(); break; } }
void Player::UpdatePhysics(float dt) { // Integrate velocity vec3 acceleration = m_force + (m_gravityDirection * 9.81f)*4.0f; m_velocity += acceleration * dt; // Check collision { vec3 velocityToUse = m_velocity + m_movementVelocity; vec3 velAmount = velocityToUse*dt; vec3 pNormal; int numberDivision = 1; while (length(velAmount) >= 1.0f) { numberDivision++; velAmount = velocityToUse*(dt / numberDivision); } for (int i = 0; i < numberDivision; i++) { float dtToUse = (dt / numberDivision) + ((dt / numberDivision) * i); vec3 posToCheck = GetCenter() + velocityToUse*dtToUse; if (CheckCollisions(posToCheck, m_previousPosition, &pNormal, &velAmount)) { // Reset velocity, we don't have any bounce m_velocity = vec3(0.0f, 0.0f, 0.0f); velocityToUse = vec3(0.0f, 0.0f, 0.0f); if (m_bCanJump == false) { m_bCanJump = true; } } } // Integrate position m_position += velocityToUse * dt; m_movementVelocity -= (m_movementVelocity * (7.5f * dt)); } // Store previous position m_previousPosition = m_position; }
void MyBOManager::Update(void) { for (uint nObject = 0; nObject < m_nObjectCount; nObject++) { m_llCollidingIndices[nObject].clear(); } static MyOctant head = MyOctant(true); if (buildOctree) { head.CheckForObjs(); buildOctree = false; } if (octreeVisible) head.Display(); CheckCollisions(head); }
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 Animation::NextBeat() { unsigned i; curr_beat++; if (curr_beat >= sheets.at(curr_sheetnum).GetNumBeats()) { return NextSheet(); } for (i = 0; i < numpts; i++) { if (!(*curr_cmds.at(i))->NextBeat(pts[i])) { // Advance to next command, skipping zero beat commands if ((curr_cmds[i] + 1) != sheets.at(curr_sheetnum).commands.at(i).end()) { ++curr_cmds[i]; BeginCmd(i); } } } CheckCollisions(); return true; }
void Combat::PlayerAttack() { CheckCollisions(PLAYER); list<Enemy*>::iterator It; eList = g_pGame->getEnemyList(); for(It = eList.begin(); It != eList.end(); ++It) { if((*It)->getHit()) { float hp = (*It)->getCurrentHP(); hp-=g_pPlayer->getDMG(); (*It)->setCurrentHP(hp); (*It)->setHit(false); cout << "Enemy-HP: " << (*It)->getCurrentHP() << endl; } } // return the list to original enemy-list // g_pGame->setEnemyList(eList); }
void Animation::GotoSheet(unsigned i) { curr_sheetnum = i; RefreshSheet(); CheckCollisions(); }
void PointSetWithCollisions::AfterStep(double deltaTime) { CheckCollisions(deltaTime); }
void Ball::Update(sf::Time& deltaTime) { position = gameBall.getPosition(); gameBall.move(velocity.x * deltaTime.asSeconds(), velocity.y * deltaTime.asSeconds()); CheckCollisions(); }
/* Returns true if node state is within bounds and obstacle-free */ bool Pendulum::Feasible(Node* n) { return (CheckBounds(n) && CheckCollisions(n)); }
void CKinematics2DEngine::CollisionsDetection( void ) { if(!m_bDetectCollisions) return; for( TKinematics2DEntityMap::const_iterator it1 = m_tPhysicsEntities.begin(); it1 != m_tPhysicsEntities.end(); ++it1 ) { bool it1_enabled = it1->second->IsEnabled(); TKinematics2DCollisionType it1_type = it1->second->GetCollisionType(); TKinematics2DEntityMap::const_iterator it2 = it1; for( ++it2; it2 != m_tPhysicsEntities.end(); ++it2 ) { bool it2_enabled = it2->second->IsEnabled(); TKinematics2DCollisionType it2_type = it2->second->GetCollisionType(); // skip collision detection if both entity are disabled or if // one of them has no collision model if( (!it1_enabled && !it2_enabled) || (it1_type == KINEMATICS2D_COLLISION_NONE) || (it2_type == KINEMATICS2D_COLLISION_NONE) ) { continue; } // check intersection between bounding boxes if( !it1->second->GetEmbodiedEntity().GetBoundingBox().Intersects( it2->second->GetEmbodiedEntity().GetBoundingBox() ) ) { continue; } bool collision_detected = false; if( (it1_type == KINEMATICS2D_COLLISION_CIRCLE) && (it2_type == KINEMATICS2D_COLLISION_CIRCLE) ) { collision_detected = CheckCollisions(dynamic_cast<CKinematics2DCollisionCircle*>(it1->second), dynamic_cast<CKinematics2DCollisionCircle*>(it2->second)); } else if( (it1_type == KINEMATICS2D_COLLISION_RECTANGLE) && (it2_type == KINEMATICS2D_COLLISION_CIRCLE) ) { collision_detected = CheckCollisions(dynamic_cast<CKinematics2DCollisionCircle*>(it2->second), dynamic_cast<CKinematics2DCollisionRectangle*>(it1->second)); } else if( (it1_type == KINEMATICS2D_COLLISION_CIRCLE) && (it2_type == KINEMATICS2D_COLLISION_RECTANGLE) ) { collision_detected = CheckCollisions(dynamic_cast<CKinematics2DCollisionCircle*>(it1->second), dynamic_cast<CKinematics2DCollisionRectangle*>(it2->second)); } else if( (it1_type == KINEMATICS2D_COLLISION_RECTANGLE) && (it2_type == KINEMATICS2D_COLLISION_RECTANGLE) ) { collision_detected = CheckCollisions(dynamic_cast<CKinematics2DCollisionRectangle*>(it1->second), dynamic_cast<CKinematics2DCollisionRectangle*>(it2->second)); } else { continue; } /* reset to previous positions if collision is detected */ if( collision_detected ) { it1->second->RevertPositionAndOrientation(); it1->second->GetEmbodiedEntity().SetCollisionDetected(); it2->second->RevertPositionAndOrientation(); it2->second->GetEmbodiedEntity().SetCollisionDetected(); } } } }
void Player::UpdatePhysics(float dt) { m_positionMovementAmount = vec3(0.0f, 0.0f, 0.0f); // Step up animation float stepUpAddition = 0.0f; if (m_bDoStepUpAnimation) { stepUpAddition = m_stepUpAnimationYAmount - m_stepUpAnimationPrevious; m_position.y += stepUpAddition; m_stepUpAnimationPrevious = m_stepUpAnimationYAmount; } // Integrate velocity vec3 acceleration = m_force + (m_gravityDirection * 9.81f)*4.0f; m_velocity += acceleration * dt; // Check collision { vec3 velocityToUse = m_velocity; vec3 velAmount = velocityToUse*dt; vec3 pNormal; int numberDivision = 1; while (length(velAmount) >= 1.0f) { numberDivision++; velAmount = velocityToUse*(dt / numberDivision); } for (int i = 0; i < numberDivision; i++) { float dtToUse = (dt / numberDivision) + ((dt / numberDivision) * i); vec3 posToCheck = GetCenter() + velocityToUse*dtToUse; bool stepUp = false; if (CheckCollisions(posToCheck, m_previousPosition, &pNormal, &velAmount, &stepUp)) { // Reset velocity, we don't have any bounce m_velocity = vec3(0.0f, 0.0f, 0.0f); velocityToUse = vec3(0.0f, 0.0f, 0.0f); if (velocityToUse.y <= 0.0f) { if (m_bCanJump == false) { m_bCanJump = true; } } } } // Integrate position m_position += velocityToUse * dt; m_positionMovementAmount += vec3(0.0f, stepUpAddition + m_stepUpAdditionYAmountChangedCache, 0.0f); m_positionMovementAmount += velocityToUse * dt; } m_stepUpAdditionYAmountChangedCache = 0.0f; // Store previous position m_previousPosition = GetCenter(); }
void CollisionSystem::Update(float dt) { // Avoid warnings for not using dt. LOG_D("[CollisionSystem] Update: " << dt); CheckCollisions(); }