-

Author: codenamecpp

gamedata/entities/weapons.json

@@ -55,7 +55,7 @@
         "base_hit_range": 1.1,
         "base_fire_rate": 15.0,
         "base_ammo_limit": 999,
-        "base_damage": 3,
+        "base_damage": 4,
 
         "hud_sprite": 33
     },

src/Decoration.h

@@ -6,9 +6,6 @@ class Decoration final: public GameObject
 {
     friend class GameObjectsManager;
 
-    // add runtime information support for gameobject
-    decl_rtti(Decoration, GameObject)
-
 public:
     Decoration(GameObjectID id, GameObjectStyle* desc);
     ~Decoration();

src/Explosion.cpp

@@ -2,6 +2,10 @@
 #include "Explosion.h"
 #include "TimeManager.h"
 #include "SpriteManager.h"
+#include "DebugRenderer.h"
+#include "PhysicsManager.h"
+#include "Pedestrian.h"
+#include "Vehicle.h"
 
 Explosion::Explosion(GameObjectID id) 
     : GameObject(eGameObjectClass_Explosion, id)
@@ -25,6 +29,11 @@ void Explosion::UpdateFrame()
         mDrawSprite.SetOriginToCenter();
     }
 
+    if (!IsDamageDone())
+    {
+        ProcessDamage();
+    }
+
     if (!mAnimationState.IsAnimationActive())
     {
         MarkForDeletion();
@@ -33,6 +42,11 @@ void Explosion::UpdateFrame()
 
 void Explosion::DrawDebug(DebugRenderer& debugRender)
 {
+    float damageRadiusA = gGameParams.mExplosionPrimaryDamageDistance;
+    float damageRadiusB = gGameParams.mExplosionSecondaryDamageDistance;
+
+    debugRender.DrawSphere(mExplosionEpicentre, damageRadiusA, Color32_Red, false);
+    debugRender.DrawSphere(mExplosionEpicentre, damageRadiusB, Color32_Yellow, false);
 }
 
 void Explosion::Spawn(const glm::vec3& startPosition)
@@ -53,4 +67,54 @@ void Explosion::Spawn(const glm::vec3& startPosition)
         debug_assert(false);
     }
     mDrawSprite.SetOriginToCenter();
-}
+
+    mExplosionEpicentre = startPosition;
+}
+
+bool Explosion::IsDamageDone() const
+{
+    return mDamageDone;
+}
+
+void Explosion::ProcessDamage()
+{
+    float maxImpactRadius = gGameParams.mExplosionPrimaryDamageDistance;
+    float minImpactRadius = gGameParams.mExplosionSecondaryDamageDistance;
+
+    float impactRadius = std::max(maxImpactRadius, minImpactRadius);
+
+    glm::vec2 centerPoint (mExplosionEpicentre.x, mExplosionEpicentre.z);
+    glm::vec2 extents (
+        impactRadius,
+        impactRadius
+    );
+
+    // single shot
+    mDamageDone = true;
+
+    // todo: fix distance to target
+    PhysicsQueryResult queryResult;
+    gPhysics.QueryObjectsWithinBox(centerPoint, extents, queryResult);
+
+    if (queryResult.IsNull())
+        return;
+
+    for (int icurr = 0; icurr < queryResult.mElementsCount; ++icurr)
+    {
+        PhysicsQueryElement& currElement = queryResult.mElements[icurr];
+
+        if (CarPhysicsBody* carPhysics = currElement.mCarComponent)
+        {
+            // todo: temporary implementation
+            carPhysics->mReferenceCar->ReceiveDamage(gGameParams.mExplosionPrimaryDamage);
+            continue;
+        }
+
+        if (PedPhysicsBody* pedPhysics = currElement.mPedComponent)
+        {
+            // todo: temporary implementation
+            pedPhysics->mReferencePed->ReceiveDamageFromExplosion(this);
+            continue;
+        }
+    }
+}

src/Explosion.h

@@ -5,10 +5,7 @@
 class Explosion final: public GameObject
 {
     friend class GameObjectsManager;
-
-    // add runtime information support for gameobject
-    decl_rtti(Explosion, GameObject)
-
+  
 public:
     Explosion(GameObjectID id);
     ~Explosion();
@@ -21,6 +18,14 @@ class Explosion final: public GameObject
     // Setup initial state when spawned or respawned on level
     void Spawn(const glm::vec3& startPosition);
 
+    // Test whether explosion did its damage and can't hurt
+    bool IsDamageDone() const;
+
+private:
+    void ProcessDamage();
+
 private:
     SpriteAnimation mAnimationState;
+    glm::vec3 mExplosionEpicentre;
+    bool mDamageDone = false;
 };

src/GameObject.h

@@ -10,9 +10,6 @@ class GameObject: public cxx::noncopyable
     friend class GameObjectsManager;
     friend class MapRenderer;
 
-    // add runtime information support for gameobject
-    decl_rtti_base(GameObject)
-
 public:
     const GameObjectID mObjectID; // its unique for all game objects except projectiles or effects, see GAMEOBJECT_ID_NULL
     const eGameObjectClass mObjectTypeID;

src/GameObjectsManager.cpp

@@ -43,10 +43,9 @@ void GameObjectsManager::UpdateFrame()
 
     // if is safe to add new objects during loop by adding them to the end of the list
 
-    const size_t allObjectsCount = mAllObjectsList.size();
-    for (size_t iobject = 0; iobject < allObjectsCount; ++iobject)
+    for (size_t i = 0, NumElements = mAllObjectsList.size(); i < NumElements; ++i)
     {
-        GameObject* currentObject = mAllObjectsList[iobject];
+        GameObject* currentObject = mAllObjectsList[i];
         currentObject->UpdateFrame();
     }
 }

src/GameParams.cpp

@@ -10,6 +10,9 @@ GameParams::GameParams()
 
 void GameParams::SetToDefaults()
 {
+    // todo: move to config
+
+    // pedestrians
     mPedestrianBoundsSphereRadius = Convert::MapUnitsToMeters(0.10f);
     mPedestrianTurnSpeed = 260.0f;
     mPedestrianTurnSpeedSlideOnCar = 120.0f;
@@ -20,4 +23,9 @@ void GameParams::SetToDefaults()
     mPedestrianKnockedDownTime = 3.0f;
     mPedestrianFallDeathHeight = Convert::MapUnitsToMeters(2.0f);
     mPedestrianDrowningTime = 0.05f;
+    // etc
+    mExplosionPrimaryDamageDistance = Convert::MapUnitsToMeters(0.7f);
+    mExplosionSecondaryDamageDistance = Convert::MapUnitsToMeters(1.2f);
+    mExplosionPrimaryDamage = 100;
+    mExplosionSecondaryDamage = 20;
 }

src/GameParams.h

@@ -23,6 +23,13 @@ class GameParams
     float mPedestrianSpotTheCarDistance; // max distance to detect the car, meters
     float mPedestrianFallDeathHeight; // falling distance which causes pedestrian death, meters
     float mPedestrianDrowningTime; // seconds
+
+    // etc
+    float mExplosionPrimaryDamageDistance; // how far explosion can do maximum damage, meters
+    float mExplosionSecondaryDamageDistance; // how far explosion can do significant damage, meters
+    int mExplosionPrimaryDamage; // hit points to injure at Primary Damage Distance
+    int mExplosionSecondaryDamage; // hit points to injure at Secondary Damage Distance
+   
 };
 
 extern GameParams gGameParams;

src/Obstacle.h

@@ -6,9 +6,6 @@ class Obstacle final: public GameObject
 {
     friend class GameObjectsManager;
 
-    // add runtime information support for gameobject
-    decl_rtti(Obstacle, GameObject)
-
 public:
     Obstacle(GameObjectID id, GameObjectStyle* desc);
     ~Obstacle();

src/Pedestrian.cpp

@@ -209,6 +209,9 @@ void Pedestrian::EnterCar(Vehicle* targetCar, eCarSeat targetSeat)
     debug_assert(targetSeat != eCarSeat_Any);
     debug_assert(targetCar);
 
+    if (targetCar->IsWrecked())
+        return;
+
     if (IsIdle())
     {
         PedestrianStateEvent evData { ePedestrianStateEvent_EnterCar };
@@ -227,11 +230,13 @@ void Pedestrian::ExitCar()
     }
 }
 
-void Pedestrian::ReceiveDamage(eWeaponID weapon, Pedestrian* attacker)
+void Pedestrian::ReceiveDamage(WeaponInfo* weapon, Pedestrian* attacker)
 {
+    debug_assert(weapon);
+
     PedestrianStateEvent evData { ePedestrianStateEvent_DamageFromWeapon };
     evData.mAttacker = attacker;
-    evData.mWeaponType = weapon;
+    evData.mWeapon = weapon;
     mStatesManager.ProcessEvent(evData);
 }
 
@@ -371,9 +376,11 @@ void Pedestrian::SetDead(ePedestrianDeathReason deathReason)
     }
 }
 
-void Pedestrian::ReceiveHitByCar(Vehicle* targetCar, float impulse)
+void Pedestrian::ReceiveDamageFromCar(Vehicle* targetCar, float impulse)
 {
-    debug_assert(targetCar);
+    debug_assert(targetCar); 
+
+    // todo: hit processing logic should be moved to states manager !
 
     if (IsDead())
         return;
@@ -408,3 +415,13 @@ void Pedestrian::ReceiveHitByCar(Vehicle* targetCar, float impulse)
     }
 }
 
+void Pedestrian::ReceiveDamageFromExplosion(Explosion* explosion)
+{
+    // todo: hit processing logic should be moved to states manager !
+
+    if (IsDead())
+        return;
+
+    Die(ePedestrianDeathReason_BlownUp, nullptr);
+}
+