Ticket #4270: fix-visualactor-save-reload.3.patch

source/simulation2/components/CCmpUnitMotion.cpp

@@ -339 +339 @@
         serialize.NumberFixed_Unbounded("target max range", m_TargetMaxRange);
 
         serialize.NumberFixed_Unbounded("speed", m_Speed);
+        serialize.NumberFixed_Unbounded("current speed", m_CurSpeed);
 
         serialize.Bool("moving", m_Moving);
         serialize.Bool("facePointAfterMove", m_FacePointAfterMove);

source/simulation2/components/CCmpVisualActor.cpp

@@ -81 +81 @@
     std::wstring m_SoundGroup;
     fixed m_AnimDesync;
     fixed m_AnimSyncRepeatTime; // 0.0 if not synced
+    fixed m_AnimSyncOffsetTime;
 
     std::map<CStr, CStr> m_VariantSelections;
 
@@ -205 +206 @@
         
         InitModel(paramNode);
 
-        // We need to select animation even if graphics are disabled, as this modifies serialized state
         SelectAnimation("idle", false, fixed::FromInt(1), L"");
     }
 
@@ -225 +225 @@
         serialize.NumberFixed_Unbounded("g", m_G);
         serialize.NumberFixed_Unbounded("b", m_B);
 
+        SerializeMap<SerializeString, SerializeString>()(serialize, "anim overrrides", m_AnimOverride);
+
         serialize.NumberFixed_Unbounded("anim run threshold", m_AnimRunThreshold);
         serialize.StringASCII("anim name", m_AnimName, 0, 256);
         serialize.Bool("anim once", m_AnimOnce);
@@ -232 +234 @@
         serialize.String("sound group", m_SoundGroup, 0, 256);
         serialize.NumberFixed_Unbounded("anim desync", m_AnimDesync);
         serialize.NumberFixed_Unbounded("anim sync repeat time", m_AnimSyncRepeatTime);
+        serialize.NumberFixed_Unbounded("anim sync offset time", m_AnimSyncOffsetTime);
 
         SerializeMap<SerializeString, SerializeString>()(serialize, "variation", m_VariantSelections);
 
@@ -264 +267 @@
         // If we serialized a different seed or different actor, reload actor
         if (oldSeed != GetActorSeed() || m_BaseActorName != m_ActorName)
             ReloadActor();
-        else if (m_Unit)
-            m_Unit->SetEntitySelection(m_VariantSelections);
-
-        fixed repeattime = m_AnimSyncRepeatTime; // save because SelectAnimation overwrites it
-
-        if (m_AnimRunThreshold.IsZero())
-            SelectAnimation(m_AnimName, m_AnimOnce, m_AnimSpeed, m_SoundGroup);
         else
-            SelectMovementAnimation(m_AnimRunThreshold);
+            ReloadUnitAnimation();
 
-        SetAnimationSyncRepeat(repeattime);
-
         if (m_Unit)
         {
             CmpPtr<ICmpOwnership> cmpOwnership(GetEntityHandle());
@@ -287 +281 @@
     virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
     {
         // Quick exit for running in non-graphical mode
-        if (m_Unit == NULL)
-            return;
+        //if (!m_Unit)
+        //  return;
 
         switch (msg.GetType())
         {
@@ -301 +295 @@
         case MT_OwnershipChanged:
         {
             const CMessageOwnershipChanged& msgData = static_cast<const CMessageOwnershipChanged&> (msg);
-            m_Unit->GetModel().SetPlayerID(msgData.to);
+            if (m_Unit) { m_Unit->GetModel().SetPlayerID(msgData.to); }
             break;
         }
         case MT_TerrainChanged:
         {
             const CMessageTerrainChanged& msgData = static_cast<const CMessageTerrainChanged&> (msg);
-            m_Unit->GetModel().SetTerrainDirty(msgData.i0, msgData.j0, msgData.i1, msgData.j1);
+            if (m_Unit) { m_Unit->GetModel().SetTerrainDirty(msgData.i0, msgData.j0, msgData.i1, msgData.j1); }
             break;
         }
         case MT_ValueModification:
@@ -435 +429 @@
         m_AnimDesync = fixed::FromInt(1)/20; // TODO: make this an argument
         m_AnimSyncRepeatTime = fixed::Zero();
 
+        SetVariant("animation", m_AnimName);
+
         if (m_Unit)
         {
-            SetVariant("animation", m_AnimName);
             if (m_Unit->GetAnimation())
                 m_Unit->GetAnimation()->SetAnimationState(m_AnimName, m_AnimOnce, m_AnimSpeed.ToFloat(), m_AnimDesync.ToFloat(), m_SoundGroup.c_str());
         }
@@ -457 +452 @@
 
     virtual void SelectMovementAnimation(fixed runThreshold)
     {
+        SelectAnimation("walk", false, fixed::FromFloat(1.f), L"");
         m_AnimRunThreshold = runThreshold;
-
-        if (m_Unit)
-        {
-            SetVariant("animation", "walk");
-            if (m_Unit->GetAnimation())
-                m_Unit->GetAnimation()->SetAnimationState("walk", false, 1.f, 0.f, L"");
-        }
     }
 
     virtual void SetAnimationSyncRepeat(fixed repeattime)
@@ -480 +469 @@
 
     virtual void SetAnimationSyncOffset(fixed actiontime)
     {
+        m_AnimSyncOffsetTime = actiontime;
+
         if (m_Unit)
         {
             if (m_Unit->GetAnimation())
-                m_Unit->GetAnimation()->SetAnimationSyncOffset(actiontime.ToFloat());
+                m_Unit->GetAnimation()->SetAnimationSyncOffset(m_AnimSyncOffsetTime.ToFloat());
         }
     }
 
@@ -546 +537 @@
     /// Helper method; initializes the model selection shape descriptor from XML. Factored out for readability of @ref Init.
     void InitSelectionShapeDescriptor(const CParamNode& paramNode);
 
+    // ReloadActor is used when the actor or seed changes.
     void ReloadActor();
+    // ReloadUnitAnimation is used for a minimal reloading upon deserialization, when the actor and seed are identical.
+    // It is also used by ReloadActor.
+    void ReloadUnitAnimation();
 
     void Update(fixed turnLength);
 };
@@ -720 +715 @@
 
     InitModel(node->GetChild("VisualActor"));
 
-    m_Unit->SetEntitySelection(m_VariantSelections);
+    ReloadUnitAnimation();
 
-    if (m_Unit->GetAnimation())
-        m_Unit->GetAnimation()->SetAnimationState(m_AnimName, m_AnimOnce, m_AnimSpeed.ToFloat(), m_AnimDesync.ToFloat(), m_SoundGroup.c_str());
-
-    // We'll lose the exact synchronisation but we should at least make sure it's going at the correct rate
-    if (!m_AnimSyncRepeatTime.IsZero())
-        if (m_Unit->GetAnimation())
-            m_Unit->GetAnimation()->SetAnimationSyncRepeat(m_AnimSyncRepeatTime.ToFloat());
-
     m_Unit->GetModel().SetShadingColor(shading);
 
     m_Unit->GetModel().SetPlayerID(playerID);
@@ -743 +730 @@
     }
 }
 
-void CCmpVisualActor::Update(fixed UNUSED(turnLength))
+void CCmpVisualActor::ReloadUnitAnimation()
 {
     if (!m_Unit)
         return;
 
-    // If we're in the special movement mode, select an appropriate animation
-    if (!m_AnimRunThreshold.IsZero())
-    {
-        CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
-        if (!cmpPosition || !cmpPosition->IsInWorld())
-            return;
+    m_Unit->SetEntitySelection(m_VariantSelections);
 
-        CmpPtr<ICmpUnitMotion> cmpUnitMotion(GetEntityHandle());
-        if (!cmpUnitMotion)
-            return;
+    if (!m_Unit->GetAnimation())
+        return;
 
-        float speed = cmpUnitMotion->GetCurrentSpeed().ToFloat();
+    m_Unit->GetAnimation()->SetAnimationState(m_AnimName, m_AnimOnce, m_AnimSpeed.ToFloat(), m_AnimDesync.ToFloat(), m_SoundGroup.c_str());
 
-        std::string name;
-        if (speed == 0.0f)
-            name = "idle";
-        else
-            name = (speed < m_AnimRunThreshold.ToFloat()) ? "walk" : "run";
+    // We'll lose the exact synchronisation but we should at least make sure it's going at the correct rate
+    if (!m_AnimSyncRepeatTime.IsZero())
+        m_Unit->GetAnimation()->SetAnimationSyncRepeat(m_AnimSyncRepeatTime.ToFloat());
+    if (!m_AnimSyncOffsetTime.IsZero())
+        m_Unit->GetAnimation()->SetAnimationSyncOffset(m_AnimSyncOffsetTime.ToFloat());
+}
 
-        std::map<std::string, std::string>::const_iterator it = m_AnimOverride.find(name);
-        if (it != m_AnimOverride.end())
-            name = it->second;
+void CCmpVisualActor::Update(fixed UNUSED(turnLength))
+{
+    // This function is currently only used to update the animation if the speed in
+    // CCmpUnitMotion changes. This also only happens in the "special movement mode"
+    // triggered by SelectMovementAnimation.
 
-        SetVariant("animation", name);
-        if (m_Unit->GetAnimation())
-        {
-            if (speed == 0.0f)
-                m_Unit->GetAnimation()->SetAnimationState(name, false, 1.f, 0.f, L"");
-            else
-                m_Unit->GetAnimation()->SetAnimationState(name, false, speed, 0.f, L"");
-        }
+    // TODO: This should become event based, in order to save performance and to make the code
+    // far less hacky. We should also take into account the speed when the animation is different
+    // from the "special movement mode" walking animation.
+
+    // If we're not in the special movement mode, nothing to do.
+    if (m_AnimRunThreshold.IsZero())
+        return;
+
+    CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
+    if (!cmpPosition || !cmpPosition->IsInWorld())
+        return;
+
+    CmpPtr<ICmpUnitMotion> cmpUnitMotion(GetEntityHandle());
+    if (!cmpUnitMotion)
+        return;
+
+    fixed speed = cmpUnitMotion->GetCurrentSpeed();
+    std::string name;
+
+    if (speed.IsZero())
+    {
+        speed = fixed::FromFloat(1.f);
+        name = "idle";
     }
+    else
+        name = (speed < m_AnimRunThreshold) ? "walk" : "run";
+
+    std::map<std::string, std::string>::const_iterator it = m_AnimOverride.find(name);
+    if (it != m_AnimOverride.end())
+        name = it->second;
+
+    // Selecting the animation is going to reset the anim run threshold, so save it
+    fixed runThreshold = m_AnimRunThreshold;
+    SelectAnimation(name, false, speed, L"");
+    m_AnimRunThreshold = runThreshold;
 }