Ticket #2319: Physics.patch

binaries/data/mods/public/simulation/templates/template_unit.xml

@@ -21 +21 @@
     <DelayTime>80.0</DelayTime>
     <SinkRate>0.01</SinkRate>
     <SinkAccel>0.0</SinkAccel>
+    <DecayType>physics</DecayType>
+    <PhysicsParameters>
+        <GroundFriction>0.1</GroundFriction>
+        <AirFriction>0.2</AirFriction>
+        <Weight>50.0</Weight>
+    </PhysicsParameters>
   </Decay>
   <Footprint>
     <Circle radius="1.5"/>

binaries/data/mods/public/simulation/helpers/Damage.js

@@ -51 +51 @@
             warn("The " + data.shape + " splash damage shape is not implemented!");
         }
         // Call CauseDamage which reduces the hitpoints, posts network command, plays sounds....
-        Damage.CauseDamage({"strengths":data.strengths, "target":entity, "attacker":data.attacker, "multiplier":damageMultiplier, "type":data.type + ".Splash"})
+        Damage.CauseDamage({"strengths":data.strengths, "target":entity, "attacker":data.attacker, "multiplier":damageMultiplier, "type":data.type + ".Splash", "origin" : data.origin })
     }
 };
 
@@ -62 +62 @@
  * data.attacker = <entity id>
  * data.multiplier = <float between 1 and 0>
  * data.type = <string>
+ * data.origin = {'x':<int>, 'z':<int>}
  */
 Damage.CauseDamage = function(data)
 {
@@ -78 +79 @@
     if (targetState.killed)
         Damage.TargetKilled(data.attacker, data.target);
 
+    if (targetState.corpse)
+    {
+        if (data.type.search("Splash") !== -1)
+        {
+            var cmpDecay = Engine.QueryInterface(targetState.corpse, IID_Decay);
+            if (cmpDecay)
+            {
+                var cmpEPos = Engine.QueryInterface(data.target, IID_Position);
+                var pos = [cmpEPos.GetPosition().x-data["origin"].x,cmpEPos.GetPosition().z-data["origin"].z];
+                cmpDecay.ApplyForce(pos[0]*4.0,10.0,pos[1]*4.0);
+            }
+        }
+    }
+    
     // Post the network command (make it work in multiplayer)
     Engine.PostMessage(data.target, MT_Attacked, {"attacker":data.attacker, "target":data.target, "type":data.type, "damage":-targetState.change});
 

binaries/data/mods/public/simulation/components/Health.js

@@ -150 +150 @@
  */
 Health.prototype.Reduce = function(amount)
 {
-    var state = { "killed": false };
+    var state = { "killed": false ,"corpse" : undefined };
     if (amount >= 0 && this.hitpoints == this.GetMaxHitpoints())
     {
         var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
@@ -175 +175 @@
 
             if (this.template.DeathType == "corpse")
             {
-                this.CreateCorpse();
+                state.corpse = this.CreateCorpse();
                 Engine.DestroyEntity(this.entity);
             }
             else if (this.template.DeathType == "vanish")

source/simulation2/components/ICmpPosition.h

@@ -105 +105 @@
     virtual bool IsFloating() = 0;
 
     /**
+     * Set whether an entity floats on water
+     */
+    virtual void SetFloating(bool newValue) = 0;
+
+    /**
      * Returns the current x,y,z position (no interpolation).
      * Depends on the current terrain heightmap.
      * Must not be called unless IsInWorld is true.

source/simulation2/components/ICmpDecay.h

@@ -26 +26 @@
 class ICmpDecay : public IComponent
 {
 public:
+    // adds directly to the fake physics "force".
+    virtual void ApplyForce(float x, float y, float z) = 0;
+    
     DECLARE_INTERFACE_TYPE(Decay)
 };
 

source/simulation2/components/CCmpDecay.cpp

@@ -25 +25 @@
 #include "ICmpPosition.h"
 #include "ICmpTerrain.h"
 #include "ICmpVisual.h"
+#include "ICmpWaterManager.h"
 
 /**
  * Fairly basic decay implementation, for units and buildings etc.
@@ -49 +50 @@
     {
         componentManager.SubscribeToMessageType(MT_Interpolate);
     }
+    
+    enum {
+        DECAY_CLASSIC = 0,
+        DECAY_SHIP = 1,
+        DECAY_PHYSICS = 2
+    };
 
     DEFAULT_COMPONENT_ALLOCATOR(Decay)
 
     bool m_Active;
-    bool m_ShipSink;
+    bool m_ReallyInited;
+    uint8_t m_DecayType;
+    
     float m_DelayTime;
     float m_SinkRate;
     float m_SinkAccel;
-
+    
+    // for physics decay only
+    CVector3D m_Force;
+    float m_GroundFriction; // a fake friction, so that a round object might roll down a hill but a human probably won't.
+    float m_AirFriction;    // note that values range [0..1] for both frictions where 1 means none and 0 means total stop.
+    float m_Weight;
+    CFixedVector3D m_PositionOneSecAgo; // to check if we should go into basic decay.
+    float m_LastPositionCheck;
+    
+    // for ship-like sinking only
     entity_pos_t m_InitialXRotation;
     entity_pos_t m_InitialZRotation;
-
-    // Used to randomize ship-like sinking
     float m_SinkingAngleX;
     float m_SinkingAngleZ;
 
@@ -86 +102 @@
                 "</element>"
             "</optional>"
             "<optional>"
-                "<element name='SinkingAnim' a:help='If this element is present, the entity will decay in a ship-like manner'>"
-                    "<empty/>"
+                "<element name='DecayType' a:help='You can choose from three different behaviors for decaying.'>"
+                    "<choice>"
+                        "<value a:help='Decay straight into the ground after an optional delay. Default value.'>classic</value>"
+                        "<value a:help='Sink like a ship would.'>ship</value>"
+                        "<value a:help='Fly in the air before decaying classically.'>physics</value>"
+                    "</choice>"
                 "</element>"
+            "</optional>"
+            "<optional>"
+                "<element name='PhysicsParameters' a:help='Parameters for the physics if decay type is \"physics\".'>"
+                    "<interleave>"
+                    "<element name='GroundFriction' a:help='How to dampen the movement when hitting the ground. 1 is complete stop, 0 is none at all. Values higher than 1 will react weirdly.'>"
+                    "<ref name='nonNegativeDecimal'/>"
+                    "</element>"
+                    "<element name='AirFriction' a:help='How to dampen the movement in the air. 1 is complete stop, 0 is none at all. Values higher than 1 might lead to weird behavior.'>"
+                    "<ref name='nonNegativeDecimal'/>"
+                    "</element>"
+                    "<element name='Weight' a:help='How much this unit is affected by gravity.'>"
+                        "<ref name='nonNegativeDecimal'/>"
+                    "</element>"
+        "</interleave>"
+                "</element>"
             "</optional>";
     }
 
     virtual void Init(const CParamNode& paramNode)
     {
         m_Active = !paramNode.GetChild("Inactive").IsOk();
-        m_ShipSink = paramNode.GetChild("SinkingAnim").IsOk();
+
+        if (!paramNode.GetChild("DecayType").IsOk() || paramNode.GetChild("DecayType").ToString() == L"classic")
+            m_DecayType = DECAY_CLASSIC;
+        else if(paramNode.GetChild("DecayType").ToString() == L"ship")
+            m_DecayType = DECAY_SHIP;
+        else if(paramNode.GetChild("DecayType").ToString() == L"physics")
+        {
+            m_DecayType = DECAY_PHYSICS;
+            if (!paramNode.GetChild("PhysicsParameters").IsOk())
+            {
+                debug_warn(L"CCmpDecay in physics mode without physics parameters");
+                m_Active = false;
+            }
+            else
+            {
+                m_Force = CVector3D();
+                m_GroundFriction = paramNode.GetChild("PhysicsParameters").GetChild("GroundFriction").ToFloat();
+                m_AirFriction = paramNode.GetChild("PhysicsParameters").GetChild("AirFriction").ToFloat();
+                m_Weight = paramNode.GetChild("PhysicsParameters").GetChild("Weight").ToFloat();
+            }
+        }
         m_DelayTime = paramNode.GetChild("DelayTime").ToFixed().ToFloat();
         m_SinkRate = paramNode.GetChild("SinkRate").ToFixed().ToFloat();
         m_SinkAccel = paramNode.GetChild("SinkAccel").ToFixed().ToFloat();
 
         m_CurrentTime = 0.f;
-        m_TotalSinkDepth = -1.f;
+        m_ReallyInited = false;
 
         // Detect unsafe misconfiguration
         if (m_Active && !ENTITY_IS_LOCAL(GetEntityId()))
@@ -144 +199 @@
                 break;
             }
 
+            CFixedVector3D pos = cmpPosition->GetPosition();
+
             // Compute the depth the first time this is called
             // (This is a bit of an ugly place to do it but at least we'll be sure
             // the actor component was loaded already)
-            if (m_TotalSinkDepth < 0.f)
+            if (!m_ReallyInited)
             {
+                m_ReallyInited = true;
                 m_TotalSinkDepth = 1.f; // minimum so we always sink at least a little
 
                 CmpPtr<ICmpVisual> cmpVisual(GetEntityHandle());
@@ -161 +219 @@
                 // If this is a floating unit, we want it to sink all the way under the terrain,
                 // so find the difference between its current position and the terrain
 
-                CFixedVector3D pos = cmpPosition->GetPosition();
 
                 CmpPtr<ICmpTerrain> cmpTerrain(GetSystemEntity());
                 if (cmpTerrain)
@@ -171 +228 @@
                 }
 
                 // Sink it further down if it sinks like a ship, as it will rotate.
-                if (m_ShipSink)
+                if (m_DecayType == DECAY_SHIP)
                 {
                     // lacking randomness we'll trick
                     m_SinkingAngleX = (pos.X.ToInt_RoundToNearest() % 30 - 15) / 15.0;
                     m_SinkingAngleZ = (pos.Z.ToInt_RoundToNearest() % 30) / 40.0;
                     m_TotalSinkDepth += 10.f;
+
+                    // probably 0 in both cases but we'll remember it anyway.
+                    m_InitialXRotation = cmpPosition->GetRotation().X;
+                    m_InitialZRotation = cmpPosition->GetRotation().Z;
                 }
-                // probably 0 in both cases but we'll remember it anyway.
-                m_InitialXRotation = cmpPosition->GetRotation().X;
-                m_InitialZRotation = cmpPosition->GetRotation().Z;
             }
 
             m_CurrentTime += msgData.deltaSimTime;
 
-            if (m_CurrentTime >= m_DelayTime)
+            if (m_DecayType == DECAY_PHYSICS)
             {
+                // decay our force and apply it
+                CmpPtr<ICmpTerrain> cmpTerrain(GetSystemEntity());
+                CmpPtr<ICmpWaterManager> cmpWaterMgr(GetSystemEntity());
+
+                pos.X += fixed::FromFloat(m_Force.X*msgData.deltaSimTime);
+                pos.Y += fixed::FromFloat(m_Force.Y*msgData.deltaSimTime);
+                pos.Z += fixed::FromFloat(m_Force.Z*msgData.deltaSimTime);
+
+                float groundLevel = cmpTerrain->GetExactGroundLevel(pos.X.ToFloat(),pos.Z.ToFloat());
+                float waterLevel = cmpWaterMgr->GetExactWaterLevel(pos.X.ToFloat(),pos.Z.ToFloat());
+
+                m_Force.Y -= m_Weight * 0.2f * msgData.deltaSimTime;
+                
+                if (pos.Y.ToFloat() < waterLevel)
+                {
+                    // just die.
+                    m_DecayType = DECAY_CLASSIC;
+                    m_ReallyInited = false;
+                    
+                    cmpPosition->SetFloating(true);
+                    m_DelayTime = m_CurrentTime-1;
+                    m_SinkRate = 0.1;
+                    m_SinkAccel = 0.1;
+                    m_LastPositionCheck = m_CurrentTime;    // avoids an update.
+                }
+                else if (pos.Y.ToFloat() > groundLevel)
+                {
+                    // just fly
+                    m_Force.X -= m_Force.X * m_AirFriction*msgData.deltaSimTime;
+                    m_Force.Y -= m_Force.Y * m_AirFriction*msgData.deltaSimTime;
+                    m_Force.Z -= m_Force.Z * m_AirFriction*msgData.deltaSimTime;
+                }
+                else
+                {
+                    // we've hit the ground
+                    CVector3D normal = cmpTerrain->CalcExactNormal(pos.X.ToFloat(),pos.Z.ToFloat());
+                    float length = m_Force.Length();
+                    m_Force *= 1.0f/length;
+                    // reflect the force, losing some speed in the process.
+                    float dot = m_Force.Dot(normal);
+                    float dampen = (1.0f-(m_GroundFriction-dot));
+                    if (dampen < 0.0f)
+                        dampen = 0.0f;
+                    m_Force = (normal * -2 * dot + m_Force) * dampen * length;
+                    
+                    pos.Y = fixed::FromFloat(groundLevel);
+                }
+                // checked if we stopped moving.
+                if (m_CurrentTime - m_LastPositionCheck > 1)
+                {
+                    if ((m_PositionOneSecAgo-pos).Length().ToFloat() < 0.5f)
+                    {
+                        m_DecayType = DECAY_CLASSIC;
+                        m_DelayTime += m_CurrentTime;
+                        m_ReallyInited = false;
+                    }
+                    m_PositionOneSecAgo = pos;
+                    m_LastPositionCheck = m_CurrentTime;
+                }
+                cmpPosition->MoveTo(pos.X,pos.Z);
+                cmpPosition->SetHeightFixed(pos.Y);
+            }
+            else if (m_CurrentTime >= m_DelayTime)
+            {
                 float t = m_CurrentTime - m_DelayTime;
                 float depth = (m_SinkRate * t) + (m_SinkAccel * t * t);
 
-                if (m_ShipSink)
+                if (m_DecayType == DECAY_SHIP)
                 {
                     // exponential sinking with tilting
                     float tilt_time = t > 5.f ? 5.f : t;
@@ -203 +325 @@
                     if (depth < 0.f)
                         depth = 0.f;
                 }
-                
                 cmpPosition->SetHeightOffset(entity_pos_t::FromFloat(-depth));
 
                 if (depth > m_TotalSinkDepth)
@@ -214 +335 @@
         }
         }
     }
+    
+    virtual void ApplyForce(float x, float y, float z)
+    {
+        m_Force.X += x;
+        m_Force.Y += y;
+        m_Force.Z += z;
+    }
+
 };
 
 REGISTER_COMPONENT_TYPE(Decay)

source/simulation2/components/ICmpDecay.cpp

@@ -22 +22 @@
 #include "simulation2/system/InterfaceScripted.h"
 
 BEGIN_INTERFACE_WRAPPER(Decay)
+DEFINE_INTERFACE_METHOD_3("ApplyForce", void, ICmpDecay, ApplyForce, float, float, float)
 END_INTERFACE_WRAPPER(Decay)

source/simulation2/components/CCmpPosition.cpp

@@ -310 +310 @@
         return m_Floating;
     }
 
+    virtual void SetFloating(bool newValue)
+    {
+        m_Floating = newValue;
+    }
+
     virtual CFixedVector3D GetPosition()
     {
         if (!m_InWorld)