Merge branch 'refactoring_gameobjects'

Author: codenamecpp

gamedata/entities/weapons.json

@@ -19,9 +19,9 @@
         "projectile_hit_object_sfx": 43, // sound index
         "projectile_offset":
         [
-            { "anim": "shoot_pistol_while_standing", "px": [8, 2] },
-            { "anim": "shoot_pistol_while_walking", "px": [11, 0] },
-            { "anim": "shoot_pistol_while_running", "px": [11, 5] }
+            { "anim": "shoot_pistol_while_standing", "px": [8, -1] },
+            { "anim": "shoot_pistol_while_walking", "px": [11, -2] },
+            { "anim": "shoot_pistol_while_running", "px": [11, 2] }
         ],
         // base params
         "base_hit_range": 4.5,
@@ -44,9 +44,9 @@
         "projectile_hit_object_sfx": 43, // sound index
         "projectile_offset":
         [
-            { "anim": "shoot_machinegun_while_standing", "px": [6, 3] },
-            { "anim": "shoot_machinegun_while_walking", "px": [10, 3] },
-            { "anim": "shoot_machinegun_while_running", "px": [11, 7] }
+            { "anim": "shoot_machinegun_while_standing", "px": [6, 0] },
+            { "anim": "shoot_machinegun_while_walking", "px": [8, 0] },
+            { "anim": "shoot_machinegun_while_running", "px": [12, 4] }
         ],
         // base params
         "base_hit_range": 4.5,
@@ -68,9 +68,9 @@
         "projectile_object": 75,
         "projectile_offset":
         [
-            { "anim": "shoot_flamethrower_while_standing", "px": [16, 3] },
-            { "anim": "shoot_flamethrower_while_walking", "px": [16, 3] },
-            { "anim": "shoot_flamethrower_while_running", "px": [18, 6] }
+            { "anim": "shoot_flamethrower_while_standing", "px": [18, 2] },
+            { "anim": "shoot_flamethrower_while_walking", "px": [18, 2] },
+            { "anim": "shoot_flamethrower_while_running", "px": [20, 5] }
         ],
         // base params
         "base_hit_range": 1.1,

src/AiCharacterController.cpp

@@ -1,7 +1,7 @@
 #include "stdafx.h"
 #include "AiCharacterController.h"
 #include "Pedestrian.h"
-#include "PhysicsComponents.h"
+#include "PhysicsBody.h"
 #include "CarnageGame.h"
 #include "DebugRenderer.h"
 #include "BroadcastEventsManager.h"
@@ -115,7 +115,7 @@ void AiCharacterController::DebugDraw(DebugRenderer& debugRender)
     if (mAiMode == ePedestrianAiMode_None || mAiMode == ePedestrianAiMode_Disabled)
         return;
 
-    glm::vec3 currpos = mCharacter->mPhysicsBody->GetPosition();
+    glm::vec3 currpos = mCharacter->mTransform.mPosition;
     glm::vec3 destpos (mDestinationPoint.x, currpos.y, mDestinationPoint.y);
 
     debugRender.DrawLine(currpos, destpos, Color32_Red, false);
@@ -137,9 +137,10 @@ bool AiCharacterController::ScanForExplosions()
     float reactionDistance2 = glm::pow(gGameParams.mAiReactOnExplosionsDistance, 2.0f);
 
     BroadcastEvent eventData;
-    if (gBroadcastEvents.PeekClosestEvent(eBroadcastEvent_Explosion, mCharacter->GetPosition2(), eventData))
+    glm::vec2 position2 = mCharacter->mTransform.GetPosition2();
+    if (gBroadcastEvents.PeekClosestEvent(eBroadcastEvent_Explosion, position2, eventData))
     {
-        if (glm::distance2(eventData.mPosition, mCharacter->GetPosition2()) > reactionDistance2) // too far away
+        if (glm::distance2(eventData.mPosition, position2) > reactionDistance2) // too far away
             return false;
 
         return true;
@@ -152,12 +153,13 @@ bool AiCharacterController::ScanForGunshots()
     float reactionDistance2 = glm::pow(gGameParams.mAiReactOnGunshotsDistance, 2.0f);
 
     BroadcastEvent eventData;
-    if (gBroadcastEvents.PeekClosestEvent(eBroadcastEvent_GunShot, mCharacter->GetPosition2(), eventData))
+    glm::vec2 position2 = mCharacter->mTransform.GetPosition2();
+    if (gBroadcastEvents.PeekClosestEvent(eBroadcastEvent_GunShot, position2, eventData))
     {
         if (eventData.mCharacter == mCharacter) // hear own gunshots
             return false; 
 
-        if (glm::distance2(eventData.mPosition, mCharacter->GetPosition2()) > reactionDistance2) // too far away
+        if (glm::distance2(eventData.mPosition, position2) > reactionDistance2) // too far away
             return false;
 
         return true;
@@ -249,7 +251,7 @@ void AiCharacterController::UpdateWandering()
     if (ContinueWalkToWaypoint(mDefaultNearDistance))
         return;
 
-    bool canFollowHuman = HasAiFlags(ePedestrianAiFlags_FollowHumanCharacter);
+    bool canFollowHuman = HasAiFlags(PedestrianAiFlags_FollowHumanCharacter);
     if (canFollowHuman)
     {
         if (TryFollowHumanCharacterNearby())
@@ -290,7 +292,7 @@ void AiCharacterController::StartWandering()
 
 bool AiCharacterController::ChooseWalkWaypoint(bool isPanic)
 {
-    cxx::angle_t currHeading = mCharacter->mPhysicsBody->GetRotationAngle();
+    cxx::angle_t currHeading = mCharacter->mTransform.mOrientation;
 
     // choose new block ir next order: forward, left, right, backward
     eMapDirection currentMapDirection = GetMapDirectionFromHeading(currHeading.mDegrees);
@@ -302,7 +304,7 @@ bool AiCharacterController::ChooseWalkWaypoint(bool isPanic)
         GetMapDirectionOpposite(currentMapDirection)
     };
 
-    glm::ivec3 currentLogPos = Convert::MetersToMapUnits(mCharacter->GetPosition());
+    glm::ivec3 currentLogPos = Convert::MetersToMapUnits(mCharacter->mTransform.mPosition);
     glm::ivec3 newWayPoint (0, 0, 0);
     for (eMapDirection curr: moveDirs)
     {
@@ -325,7 +327,7 @@ bool AiCharacterController::ChooseWalkWaypoint(bool isPanic)
                 break;
             }
 
-            bool canSuicide = HasAiFlags(ePedestrianAiFlags_LemmingBehavior);
+            bool canSuicide = HasAiFlags(PedestrianAiFlags_LemmingBehavior);
             if (canSuicide && (groundType == eGroundType_Air))
             {
                 newWayPoint = moveBlockPos;
@@ -352,17 +354,16 @@ bool AiCharacterController::ContinueWalkToWaypoint(float distance)
 {
     float tolerance2 = pow(gGameParams.mPedestrianBoundsSphereRadius, 2.0f);
 
-    glm::vec2 currentPosition = mCharacter->mPhysicsBody->GetPosition2();
-    if (glm::distance2(currentPosition, mDestinationPoint) <= tolerance2)
+    glm::vec2 currentPos2 = mCharacter->mTransform.GetPosition2();
+    if (glm::distance2(currentPos2, mDestinationPoint) <= tolerance2)
     {
         mCharacter->mCtlState.Clear();
         return false;
     }
 
     // setup sign direction
-    glm::vec2 currentPos2 = mCharacter->mPhysicsBody->GetPosition2();
     glm::vec2 toTarget = glm::normalize(mDestinationPoint - currentPos2);
-    mCharacter->mPhysicsBody->SetOrientation2(toTarget);
+    mCharacter->SetOrientation(toTarget);
 
     // set control
     mCharacter->mCtlState.mWalkForward = true;
@@ -389,7 +390,7 @@ void AiCharacterController::StopDriving()
 
     mCharacter->mCtlState.Clear();
 
-    float currentSpeed = mCharacter->mCurrentCar->mPhysicsBody->GetCurrentSpeed();
+    float currentSpeed = mCharacter->mCurrentCar->GetCurrentSpeed();
     if (currentSpeed > gGameParams.mCarSpeedPassengerCanEnter)
     {
         mCharacter->mCtlState.mAcceleration = -1.0f;
@@ -460,7 +461,7 @@ void AiCharacterController::StartFollowTarget()
     mCharacter->mCtlState.Clear();
     mAiMode = ePedestrianAiMode_FollowTarget;
 
-    mDestinationPoint = mFollowPedestrian->mPhysicsBody->GetPosition2();
+    mDestinationPoint = mFollowPedestrian->mTransform.GetPosition2();
 }
 
 void AiCharacterController::UpdateFollowTarget()
@@ -480,8 +481,8 @@ void AiCharacterController::UpdateFollowTarget()
     if (ContinueWalkToWaypoint(mFollowNearDistance))
         return;
 
-    glm::vec2 characterPosition2 = mCharacter->mPhysicsBody->GetPosition2();
-    glm::vec2 targetPosition2 = mFollowPedestrian->mPhysicsBody->GetPosition2();
+    glm::vec2 characterPosition2 = mCharacter->mTransform.GetPosition2();
+    glm::vec2 targetPosition2 = mFollowPedestrian->mTransform.GetPosition2();
 
     float distanceToTarget2 = glm::distance2(characterPosition2, targetPosition2);
     if (distanceToTarget2 < glm::pow(mFollowNearDistance, 2.0f))
@@ -495,17 +496,17 @@ void AiCharacterController::UpdateFollowTarget()
     ContinueWalkToWaypoint(mFollowNearDistance);
 }
 
-void AiCharacterController::EnableAiFlags(ePedestrianAiFlags aiFlags)
+void AiCharacterController::EnableAiFlags(PedestrianAiFlags aiFlags)
 {
     mAiFlags = (mAiFlags | aiFlags);
 }
 
-void AiCharacterController::DisableAiFlags(ePedestrianAiFlags aiFlags)
+void AiCharacterController::DisableAiFlags(PedestrianAiFlags aiFlags)
 {
     mAiFlags = (mAiFlags & ~aiFlags);
 }
 
-bool AiCharacterController::HasAiFlags(ePedestrianAiFlags aiFlags) const
+bool AiCharacterController::HasAiFlags(PedestrianAiFlags aiFlags) const
 {
     return (mAiFlags & aiFlags) == aiFlags;
 }
@@ -524,7 +525,7 @@ bool AiCharacterController::TryFollowHumanCharacterNearby()
         if (!currentPlayer->mCharacter->IsStanding())
             continue;
 
-        float currDistance2 = glm::distance2(currentPlayer->mCharacter->GetPosition2(), mCharacter->GetPosition2());
+        float currDistance2 = glm::distance2(currentPlayer->mCharacter->mTransform.GetPosition2(), mCharacter->mTransform.GetPosition2());
         if (currDistance2 > bestDistance2)
             continue;
 

src/AiCharacterController.h

@@ -20,14 +20,14 @@ enum ePedestrianAiState
     ePedestrianAiState_WalkToLocation,
 };
 
-enum ePedestrianAiFlags
+enum PedestrianAiFlags
 {
-    ePedestrianAiFlags_None = 0,
+    PedestrianAiFlags_None = 0,
 
-    ePedestrianAiFlags_LemmingBehavior = BIT(0), // can suicide
-    ePedestrianAiFlags_FollowHumanCharacter = BIT(1),
+    PedestrianAiFlags_LemmingBehavior = BIT(0), // can suicide
+    PedestrianAiFlags_FollowHumanCharacter = BIT(1),
 };
-decl_enum_as_flags(ePedestrianAiFlags);
+decl_enum_as_flags(PedestrianAiFlags);
 
 // defines ai character controller
 class AiCharacterController final: public CharacterController
@@ -39,9 +39,9 @@ class AiCharacterController final: public CharacterController
     void UpdateFrame() override;
     void DebugDraw(DebugRenderer& debugRender) override;
 
-    void EnableAiFlags(ePedestrianAiFlags aiFlags);
-    void DisableAiFlags(ePedestrianAiFlags aiFlags);
-    bool HasAiFlags(ePedestrianAiFlags aiFlags) const;
+    void EnableAiFlags(PedestrianAiFlags aiFlags);
+    void DisableAiFlags(PedestrianAiFlags aiFlags);
+    bool HasAiFlags(PedestrianAiFlags aiFlags) const;
 
     // objectives
     void FollowPedestrian(Pedestrian* pedestrian);
@@ -80,7 +80,7 @@ class AiCharacterController final: public CharacterController
     glm::vec2 mDestinationPoint;
     float mDefaultNearDistance;
 
-    ePedestrianAiFlags mAiFlags = ePedestrianAiFlags_None;
+    PedestrianAiFlags mAiFlags = PedestrianAiFlags_None;
 
     PedestrianHandle mFollowPedestrian;
     float mFollowNearDistance;

src/AudioManager.cpp

@@ -191,16 +191,16 @@ void AudioManager::ResumeAllSounds()
     }
 }
 
-SfxSample* AudioManager::GetSound(eSfxType sfxType, SfxIndex sfxIndex)
+SfxSample* AudioManager::GetSound(eSfxSampleType sfxType, SfxSampleIndex sfxIndex)
 {
-    AudioSampleArchive& sampleArchive = (sfxType == eSfxType_Level) ? mLevelSounds : mVoiceSounds;
+    AudioSampleArchive& sampleArchive = (sfxType == eSfxSampleType_Level) ? mLevelSounds : mVoiceSounds;
     if ((int) sfxIndex >= sampleArchive.GetEntriesCount())
     {
         debug_assert(false);
         return nullptr;
     }
 
-    std::vector<SfxSample*>& samples = (sfxType == eSfxType_Level) ? 
+    std::vector<SfxSample*>& samples = (sfxType == eSfxSampleType_Level) ? 
         mLevelSfxSamples : 
         mVoiceSfxSamples;
 
@@ -286,7 +286,7 @@ void AudioManager::UpdateActiveEmitters()
     {
         if (currEmitter->mGameObject) // sync audio params
         {
-            glm::vec3 gameObjectPosition = currEmitter->mGameObject->GetPosition();
+            glm::vec3 gameObjectPosition = currEmitter->mGameObject->mTransform.mPosition;
             currEmitter->UpdateEmitterParams(gameObjectPosition);
         }
 
@@ -307,7 +307,7 @@ void AudioManager::UpdateActiveEmitters()
     }
 }
 
-bool AudioManager::StartSound(eSfxType sfxType, SfxIndex sfxIndex, SfxFlags sfxFlags, const glm::vec3& emitterPosition)
+bool AudioManager::StartSound(eSfxSampleType sfxType, SfxSampleIndex sfxIndex, SfxFlags sfxFlags, const glm::vec3& emitterPosition)
 {
     SfxSample* audioSample = GetSound(sfxType, sfxIndex);
     if (audioSample == nullptr)

src/AudioManager.h

@@ -23,12 +23,12 @@ class AudioManager final: public cxx::noncopyable
     // Simple play one shot sound within world
     // @param sfxType, sfxIndex: Sound identifier
     // @param emitterPosition: Sound position
-    bool StartSound(eSfxType sfxType, SfxIndex sfxIndex, SfxFlags sfxFlags, const glm::vec3& emitterPosition);
+    bool StartSound(eSfxSampleType sfxType, SfxSampleIndex sfxIndex, SfxFlags sfxFlags, const glm::vec3& emitterPosition);
 
     // Get game sound by its identifier, will load audio data if it is not loaded yet
     // @param sfxType: Sound type
     // @param sfxIndex: Sound index
-    SfxSample* GetSound(eSfxType sfxType, SfxIndex sfxIndex);
+    SfxSample* GetSound(eSfxSampleType sfxType, SfxSampleIndex sfxIndex);
 
     // Allocate new sound emitter instance
     // @param gameObject: Game object which emitting sounds, optional

src/Box2D_Helpers.h

@@ -1,39 +1,52 @@
 #pragma once
 
-namespace box2d
+#include "GameObject.h"
+#include "PhysicsBody.h"
+#include "Collider.h"
+
+// b2Vec <- -> glm::vec2 conversion
+
+//////////////////////////////////////////////////////////////////////////
+
+inline glm::vec2 convert_vec2(const b2Vec2& vector_value)
+{
+    return { vector_value.x, vector_value.y };
+}
+
+inline b2Vec2 convert_vec2(const glm::vec2& vector_value)
+{
+    return { vector_value.x, vector_value.y };
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+inline Collider* b2Fixture_get_collider(b2Fixture* fixture)
 {
-    // simple wrapper for seamlessly cast between math libraries
-    struct vec2: public b2Vec2
+    debug_assert(fixture);
+    Collider* collisionShape = (Collider*) fixture->GetUserData();
+
+    return collisionShape;
+}
+
+inline PhysicsBody* b2Fixture_get_physics_body(b2Fixture* fixture)
+{
+    debug_assert(fixture);
+
+    PhysicsBody* physicsBoxy = (PhysicsBody*) fixture->GetBody()->GetUserData();
+    return physicsBoxy;
+}
+
+inline GameObject* b2Fixture_get_game_object(b2Fixture* fixture)
+{
+    debug_assert(fixture);
+
+    PhysicsBody* physicsBoxy = (PhysicsBody*) fixture->GetBody()->GetUserData();
+    GameObject* gameObject = nullptr;
+    if (physicsBoxy)
     {
-    public:
-        vec2() = default;
-        vec2(float xIn, float yIn): b2Vec2(xIn, yIn) 
-        {
-        }
-        template<typename TVec2>
-        vec2(const TVec2& in_vec2): b2Vec2(in_vec2.x, in_vec2.y) 
-        { 
-        }
-        template<typename TVec2>
-        inline vec2& operator = (const TVec2& in_vec2)
-        {
-            x = in_vec2.x;
-            y = in_vec2.y;
-            return *this;
-        }
-        inline operator glm::vec2 () const
-        {
-            return {x, y};
-        }
-        inline vec2 operator * (float scalar) const
-        {
-            return {x * scalar, y * scalar};
-        }
-    };
-
-    // vectors
-    static const vec2 NullVector { 0.0f, 0.0f };
-    static const vec2 ForwardVector (1.0f, 0.0f);
-    static const vec2 LateralVector (0.0f, 1.0f);
-
-} // namespace box2d
+        gameObject = physicsBoxy->mGameObject;
+    }
+    return gameObject;
+}
+
+//////////////////////////////////////////////////////////////////////////