-

Author: codenamecpp

gamedata/entities/weapons.json

@@ -20,6 +20,7 @@
         "base_hit_range": 4.5,
         "base_fire_rate": 2.0,
         "base_ammo_limit": 999,
+        "base_damage": 1,
 
         "hud_sprite": 30
     },
@@ -37,6 +38,7 @@
         "base_hit_range": 4.5,
         "base_fire_rate": 8.0,
         "base_ammo_limit": 999,
+        "base_damage": 1,
 
         "hud_sprite": 31
     },
@@ -46,13 +48,14 @@
         "fire_type": "projectile",
         // projectile data
         "projectile_type": "flame",
-        "projectile_size": 0.075,
+        "projectile_size": 0.05,
         "projectile_speed": 3.1,
         "projectile_object": 75,
         // base params
         "base_hit_range": 1.1,
         "base_fire_rate": 15.0,
         "base_ammo_limit": 999,
+        "base_damage": 3,
 
         "hud_sprite": 33
     },
@@ -69,6 +72,7 @@
         "base_hit_range": 20.0,
         "base_fire_rate": 1.0,
         "base_ammo_limit": 999,
+        "base_damage": 100,
 
         "hud_sprite": 32
     }

src/GameObjectsManager.cpp

@@ -404,4 +404,25 @@ bool GameObjectsManager::CreateStartupObjects()
         }
     }
     return true;
-}
+}
+
+int GameObjectsManager::GetBaseHitpointsForCar(eCarVType carType) const
+{
+    // todo: move to settings
+    // todo: find out correct values
+
+    switch (carType)
+    {
+        case eCarVType_Bus:
+        case eCarVType_FrontOfJuggernaut:
+        case eCarVType_BackOfJuggernaut:
+            return 29; 
+        case eCarVType_Motorcycle:
+        case eCarVType_StandardCar:
+            return 16;
+        case eCarVType_Train:
+        case eCarVType_Tank:
+            return 62;
+    }
+    return 10;
+}

src/GameObjectsManager.h

@@ -50,19 +50,23 @@ class GameObjectsManager final: public cxx::noncopyable
     // Add new obstacle instance to map at specific location
     Obstacle* CreateObstacle(const glm::vec3& position, cxx::angle_t heading, GameObjectStyle* desc);
 
-    // find gameobject by its unique identifier
+    // Find gameobject by its unique identifier
     // @param objectID: Unique identifier
     Vehicle* GetVehicleByID(GameObjectID objectID) const;
     Obstacle* GetObstacleByID(GameObjectID objectID) const;
     Decoration* GetDecorationByID(GameObjectID objectID) const;
     Pedestrian* GetPedestrianByID(GameObjectID objectID) const;
     GameObject* GetGameObjectByID(GameObjectID objectID) const;
 
-    // will immediately destroy gameobject, don't call this mehod during UpdateFrame
+    // Get base hp points for specific car type
+    // @param carType: Identifier
+    int GetBaseHitpointsForCar(eCarVType carType) const;
+
+    // Will immediately destroy gameobject, don't call this mehod during UpdateFrame
     // @param object: Object to destroy
     void DestroyGameObject(GameObject* object);
 
-    // queue gameobject for deletion, it will be destroyed next frame
+    // Queue gameobject for deletion, it will be destroyed next frame
     // @param object: Object to queue
     void MarkForDeletion(GameObject* object);
 

src/PhysicsComponents.cpp

@@ -14,7 +14,6 @@ PhysicsBody::PhysicsBody(b2World* physicsWorld)
     , mPhysicsBody()
     , mPreviousPosition()
     , mSmoothPosition()
-    , mPhysicsBodiesListNode(this)
 {
     debug_assert(physicsWorld);
 }

src/PhysicsComponents.h

@@ -96,7 +96,6 @@ class PhysicsBody: public cxx::noncopyable
 protected:
     b2World* mPhysicsWorld;
     b2Body* mPhysicsBody;
-    cxx::intrusive_node<PhysicsBody> mPhysicsBodiesListNode;
 };
 
 //////////////////////////////////////////////////////////////////////////

src/PhysicsManager.cpp

@@ -119,17 +119,17 @@ void PhysicsManager::ProcessSimulationStep()
     mPhysicsWorld->Step(mSimulationStepTime, velocityIterations, positionIterations);
 
     // process physics components
-    for (PhysicsBody* currComponent: mCarsBodiesList)
+    for (size_t i = 0, NumElements = mCarsBodiesList.size(); i < NumElements; ++i)
     {
-        currComponent->SimulationStep();
+        mCarsBodiesList[i]->SimulationStep();
     }
-    for (PhysicsBody* currComponent: mPedsBodiesList)
+    for (size_t i = 0, NumElements = mPedsBodiesList.size(); i < NumElements; ++i)
     {
-        currComponent->SimulationStep();
+        mPedsBodiesList[i]->SimulationStep();
     }
-    for (PhysicsBody* currComponent: mProjectileBodiesList)
+    for (size_t i = 0, NumElements = mProjectileBodiesList.size(); i < NumElements; ++i)
     {
-        currComponent->SimulationStep();
+        mProjectileBodiesList[i]->SimulationStep();
     }
 
     FixedStepGravity();
@@ -162,7 +162,7 @@ PedPhysicsBody* PhysicsManager::CreatePhysicsBody(Pedestrian* object, const glm:
     PedPhysicsBody* physicsObject = mPedsBodiesPool.create(mPhysicsWorld, object);
     physicsObject->SetPosition(position, rotationAngle);
 
-    mPedsBodiesList.insert(&physicsObject->mPhysicsBodiesListNode);
+    mPedsBodiesList.push_back(physicsObject);
     return physicsObject;
 }
 
@@ -174,7 +174,7 @@ CarPhysicsBody* PhysicsManager::CreatePhysicsBody(Vehicle* object, const glm::ve
     CarPhysicsBody* physicsObject = mCarsBodiesPool.create(mPhysicsWorld, object);
     physicsObject->SetPosition(position, rotationAngle);
 
-    mCarsBodiesList.insert(&physicsObject->mPhysicsBodiesListNode);
+    mCarsBodiesList.push_back(physicsObject);
     return physicsObject;
 }
 
@@ -185,7 +185,7 @@ ProjectilePhysicsBody* PhysicsManager::CreatePhysicsBody(Projectile* object, con
     ProjectilePhysicsBody* physicsObject = mProjectileBodiesPool.create(mPhysicsWorld, object);
     physicsObject->SetPosition(position, rotationAngle);
 
-    mProjectileBodiesList.insert(&physicsObject->mPhysicsBodiesListNode);
+    mProjectileBodiesList.push_back(physicsObject);
     return physicsObject;
 }
 
@@ -258,42 +258,24 @@ void PhysicsManager::CreateMapCollisionShape()
 void PhysicsManager::DestroyPhysicsBody(PedPhysicsBody* object)
 {
     debug_assert(object);
-    if (mPedsBodiesList.contains(&object->mPhysicsBodiesListNode))
-    {
-        mPedsBodiesList.remove(&object->mPhysicsBodiesListNode);
-    }
-    else
-    {
-        debug_assert(false);
-    }
+    cxx::erase_elements(mPedsBodiesList, object);
+
     mPedsBodiesPool.destroy(object);
 }
 
 void PhysicsManager::DestroyPhysicsBody(CarPhysicsBody* object)
 {
     debug_assert(object);
-    if (mCarsBodiesList.contains(&object->mPhysicsBodiesListNode))
-    {
-        mCarsBodiesList.remove(&object->mPhysicsBodiesListNode);
-    }
-    else
-    {
-        debug_assert(false);
-    }
+    cxx::erase_elements(mCarsBodiesList, object);
+
     mCarsBodiesPool.destroy(object);
 }
 
 void PhysicsManager::DestroyPhysicsBody(ProjectilePhysicsBody* object)
 {
     debug_assert(object);
-    if (mProjectileBodiesList.contains(&object->mPhysicsBodiesListNode))
-    {
-        mProjectileBodiesList.remove(&object->mPhysicsBodiesListNode);
-    }
-    else
-    {
-        debug_assert(false);
-    }
+    cxx::erase_elements(mProjectileBodiesList, object);
+
     mProjectileBodiesPool.destroy(object);
 }
 
@@ -450,11 +432,10 @@ void PhysicsManager::FixedStepGravity()
     // todo: cleanup this mess
 
     // cars
-    for (PhysicsBody* currPhysicsBody: mCarsBodiesList)
+    for (size_t i = 0, NumElements = mCarsBodiesList.size(); i < NumElements; ++i)
     {
-        CarPhysicsBody* physicsComponent = static_cast<CarPhysicsBody*>(currPhysicsBody);
-        Vehicle* currCar = physicsComponent->mReferenceCar;       
 
+        CarPhysicsBody* physicsComponent = static_cast<CarPhysicsBody*>(mCarsBodiesList[i]);
         if (physicsComponent->mWaterContact)
             continue;
 
@@ -484,9 +465,9 @@ void PhysicsManager::FixedStepGravity()
     }
 
     // pedestrians
-    for (PhysicsBody* currPhysicsBody: mPedsBodiesList)
+    for (size_t i = 0, NumElements = mPedsBodiesList.size(); i < NumElements; ++i)
     {
-        PedPhysicsBody* physicsComponent = static_cast<PedPhysicsBody*>(currPhysicsBody);
+        PedPhysicsBody* physicsComponent = static_cast<PedPhysicsBody*>(mPedsBodiesList[i]);
         Pedestrian* currPedestrian = physicsComponent->mReferencePed;
 
         if (currPedestrian->mCurrentCar)

src/PhysicsManager.h

@@ -97,9 +97,9 @@ class PhysicsManager final: private b2ContactListener
     cxx::object_pool<ProjectilePhysicsBody> mProjectileBodiesPool;
 
     // bodies lists
-    cxx::intrusive_list<PhysicsBody> mPedsBodiesList;
-    cxx::intrusive_list<PhysicsBody> mCarsBodiesList;
-    cxx::intrusive_list<PhysicsBody> mProjectileBodiesList;
+    std::vector<PhysicsBody*> mPedsBodiesList;
+    std::vector<PhysicsBody*> mCarsBodiesList;
+    std::vector<PhysicsBody*> mProjectileBodiesList;
 };
 
 extern PhysicsManager gPhysics;

src/Projectile.cpp

@@ -94,6 +94,12 @@ void Projectile::UpdateFrame()
                     hitEffect->SetLifeDuration(1);
                 }
             }
+
+            if (mContactObject && mContactObject->IsVehicleClass())
+            {
+                Vehicle* carObject = static_cast<Vehicle*>(mContactObject);
+                carObject->ReceiveDamageFromProjectile(mWeaponInfo->mBaseDamage);
+            }
         }
     }
 }

src/Vehicle.cpp

@@ -8,6 +8,7 @@
 #include "SpriteManager.h"
 #include "Pedestrian.h"
 #include "TimeManager.h"
+#include "GameObjectsManager.h"
 
 Vehicle::Vehicle(GameObjectID id) : GameObject(eGameObjectClass_Car, id)
     , mPhysicsBody()
@@ -45,6 +46,8 @@ void Vehicle::Spawn(const glm::vec3& startPosition, cxx::angle_t startRotation)
     }
 
     mDead = false;
+    mHitpoints = gGameObjectsManager.GetBaseHitpointsForCar(mCarStyle->mVType);
+
     mDamageDeltaBits = 0;
     mChassisSpriteIndex = gGameMap.mStyleData.GetCarSpriteIndex(mCarStyle->mVType, mCarStyle->mSprNum); // todo: handle bike fallen state 
 
@@ -53,6 +56,17 @@ void Vehicle::Spawn(const glm::vec3& startPosition, cxx::angle_t startRotation)
 
 void Vehicle::UpdateFrame()
 {
+    if (mDead)
+        return;
+
+    // check if car dead
+    mDead = (mHitpoints <= 0);
+    if (mDead)
+    {
+        Explode();
+        return;
+    }
+
     UpdateDeltaAnimations();
 
     UpdateDriving();
@@ -510,6 +524,34 @@ void Vehicle::ReceiveDamageFromWater()
     }
 }
 
+void Vehicle::ReceiveDamageFromProjectile(int damage)
+{
+    if (mDead)
+        return;
+
+    debug_assert(damage > 0);
+
+    if (damage > 0)
+    {
+        mHitpoints -= damage;
+    }
+}
+
+void Vehicle::Explode()
+{
+    glm::vec3 explosionPos = mPhysicsBody->GetPosition();
+    explosionPos.y = mDrawHeight + 0.2f; // todo: magic numbers
+
+    Explosion* explosion = gGameObjectsManager.CreateExplosion(explosionPos);
+    debug_assert(explosion);
+
+    // kill passengers inside
+    for (Pedestrian* currentPed: mPassengers)
+    {
+        currentPed->Die(ePedestrianDeathReason_BlownUp, nullptr);
+    }
+}
+
 bool Vehicle::HasHardTop() const
 {
     if ((mCarStyle->mConvertible == eCarConvertible_HardTop || mCarStyle->mConvertible == eCarConvertible_HardTopAnimated) && 

src/Vehicle.h

@@ -38,8 +38,9 @@ class Vehicle final: public GameObject
     // setup initial state when spawned or respawned on level
     void Spawn(const glm::vec3& startPosition, cxx::angle_t startRotation);
 
-    // todo: implement car damage system
+    // process damages
     void ReceiveDamageFromWater();
+    void ReceiveDamageFromProjectile(int damage);
 
     // adds passenger into the car
     // @param pedestrian: Pedestrian, cannot be null
@@ -91,6 +92,7 @@ class Vehicle final: public GameObject
     bool IsSeatPresent(eCarSeat carSeat) const;
 
 private:
+    void Explode();
     void UpdateDriving();
     void ComputeDrawHeight(const glm::vec3& position);
     void SetupDeltaAnimations();
@@ -104,4 +106,5 @@ class Vehicle final: public GameObject
     SpriteDeltaBits mDamageDeltaBits;
 
     int mChassisSpriteIndex = 0;
+    int mHitpoints = 20;
 };