Ticket #131: blink.patch

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

@@ -142 +142 @@
     Engine.PostMessage(this.entity, MT_CapturePointsChanged, { "capturePoints": this.cp });
 
     var owner = cmpOwnership.GetOwner();
-    if (owner == -1 || this.cp[owner] > 0)
+    if (owner == -1)
         return;
 
+    if (this.cp[owner] > 0)
+    {
+        this.UpdateBlinking();
+        return;
+    }
+
     // if all cp has been taken from the owner, convert it to the best player
     var bestPlayer = 0;
     for (let i in this.cp)
@@ -160 +166 @@
     let cmpCapturedPlayerStatisticsTracker = QueryOwnerInterface(this.entity, IID_StatisticsTracker);
     if (cmpCapturedPlayerStatisticsTracker)
         cmpCapturedPlayerStatisticsTracker.CapturedEntity(this.entity);
+
+    this.UpdateBlinking();
 };
 
+Capturable.prototype.UpdateBlinking = function()
+{
+    let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    if (!cmpOwnership)
+        return;
+
+    let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
+    if (!cmpVisual)
+        return;
+
+    let owner = cmpOwnership.GetOwner();
+    if (this.cp[owner] == this.maxCp)
+    {
+        cmpVisual.ClearBlinking();
+        return;
+    }
+
+    let bestPlayer = 0;
+    for (let i in this.cp)
+        if (i != owner && this.cp[i] >= this.cp[bestPlayer])
+            bestPlayer = +i;
+
+    let cmpPlayer = QueryPlayerIDInterface(bestPlayer);
+    if (!cmpPlayer)
+    {
+        cmpVisual.ClearBlinking();
+        return;
+    }
+    let color = cmpPlayer.GetColor();
+    cmpVisual.SetBlinking(color.r, color.g, color.b, 0.4, true, 0.4 + this.cp[owner] / this.maxCp * 4.0);
+}
+
 Capturable.prototype.GetRegenRate = function()
 {
     var regenRate = +this.template.RegenRate;

source/simulation2/components/CCmpVisualActor.cpp

@@ -83 +83 @@
     fixed m_AnimSyncRepeatTime; // 0.0 if not synced
     fixed m_AnimSyncOffsetTime;
 
+    // blinking-related, can use float since this will be purely graphical.
+    bool m_Blinking;
+    bool m_BlinkingLoop;
+    CColor m_BlinkingColor;
+    float m_BlinkingTime;
+    float m_BlinkingPeriod;
+    double m_BlinkingStart;
+
     std::map<CStr, CStr> m_VariantSelections;
 
     u32 m_Seed; // seed used for random variations
@@ -282 +290 @@
     {
         switch (msg.GetType())
         {
+        case MT_Interpolate:
+        {
+            Interpolate();
+            break;
+        }
         case MT_Update_Final:
         {
             const CMessageUpdate_Final& msgData = static_cast<const CMessageUpdate_Final&> (msg);
@@ -486 +499 @@
         }
     }
 
+    virtual void SetBlinking(float r, float g, float b, float blinkTime, bool loop, float blinkPeriod)
+    {
+        if (!m_Blinking)
+            m_BlinkingStart = timer_Time();
+
+        m_BlinkingColor = CColor(r, g, b, 1.0f);
+        m_Blinking = true;
+        m_BlinkingTime = blinkTime;
+        m_BlinkingLoop = loop;
+        m_BlinkingPeriod = blinkPeriod;
+
+        // subscribe to interpolation.
+        GetSimContext().GetComponentManager().DynamicSubscriptionNonsync(MT_Interpolate, this, true);
+    }
+
+    virtual void ClearBlinking()
+    {
+        m_Blinking = false;
+        GetSimContext().GetComponentManager().DynamicSubscriptionNonsync(MT_Interpolate, this, false);
+    }
+
     virtual void SetVariable(const std::string& name, float value)
     {
         if (m_Unit)
@@ -536 +570 @@
     void ReloadUnitAnimation();
 
     void Update(fixed turnLength);
+
+    void Interpolate();
 };
 
 REGISTER_COMPONENT_TYPE(VisualActor)
@@ -783 +819 @@
     SelectAnimation(name, false, speed, L"");
     m_AnimRunThreshold = runThreshold;
 }
+
+void CCmpVisualActor::Interpolate()
+{
+    if (!m_Blinking)
+    {
+        ClearBlinking();
+        return;
+    }
+    if (!m_Unit)
+        return;
+
+    CModelAbstract& model = m_Unit->GetModel();
+
+    double time = fmod(timer_Time()-m_BlinkingStart, (double)(m_BlinkingTime+m_BlinkingPeriod));
+
+    if (time > m_BlinkingTime)
+    {
+        if (!m_BlinkingLoop)
+        {
+            ClearBlinking();
+            return;
+        }
+        model.SetShadingColor(CColor(m_R.ToFloat(), m_G.ToFloat(), m_B.ToFloat(), 1.0f));
+        return;
+    }
+
+    CColor color(0.0f, 0.0f, 0.0f, 1.0f);
+    float influence = (float)fabs(1.0f - time/(m_BlinkingTime/2.0f));
+    color.r = m_R.ToFloat() * influence + m_BlinkingColor.r * (1.0f - influence);
+    color.g = m_G.ToFloat() * influence + m_BlinkingColor.g * (1.0f - influence);
+    color.b = m_B.ToFloat() * influence + m_BlinkingColor.b * (1.0f - influence);
+    model.SetShadingColor(color);
+}
+

source/simulation2/components/ICmpVisual.cpp

@@ -30 +30 @@
 DEFINE_INTERFACE_METHOD_1("SetAnimationSyncRepeat", void, ICmpVisual, SetAnimationSyncRepeat, fixed)
 DEFINE_INTERFACE_METHOD_1("SetAnimationSyncOffset", void, ICmpVisual, SetAnimationSyncOffset, fixed)
 DEFINE_INTERFACE_METHOD_4("SetShadingColor", void, ICmpVisual, SetShadingColor, fixed, fixed, fixed, fixed)
+DEFINE_INTERFACE_METHOD_6("SetBlinking", void, ICmpVisual, SetBlinking, float, float, float, float, bool, float)
+DEFINE_INTERFACE_METHOD_0("ClearBlinking", void, ICmpVisual, ClearBlinking)
 DEFINE_INTERFACE_METHOD_2("SetVariable", void, ICmpVisual, SetVariable, std::string, float)
 DEFINE_INTERFACE_METHOD_0("GetActorSeed", u32, ICmpVisual, GetActorSeed)
 DEFINE_INTERFACE_METHOD_1("SetActorSeed", void, ICmpVisual, SetActorSeed, u32)

source/simulation2/components/ICmpVisual.h

@@ -143 +143 @@
     virtual void SetShadingColor(fixed r, fixed g, fixed b, fixed a) = 0;
 
     /**
+     * Set the actor to blink a certain color. Purely graphical.
+     * @param r red component, expected range [0, 1]
+     * @param g green component, expected range [0, 1]
+     * @param b blue component, expected range [0, 1]
+     * @param loop whether the blinking stops after one period
+     * @param blinkTime how long should a "blink" take
+     * @param blinkPeriod how long between two blinks. Irrelevant if not looping
+     */
+    virtual void SetBlinking(float r, float g, float b, float blinkTime, bool loop = false, float blinkPeriod = 0.0f) = 0;
+
+    /**
+     * Stop blinking
+     */
+    virtual void ClearBlinking() = 0;
+
+    /**
      * Set an arbitrarily-named variable that the model may use to alter its appearance
      * (e.g. in particle emitter parameter computations).
      */