Optimization: caching unity components

new actions:
ActionBezierRel.cs
ActionBlink.cs
ActionJumpBy.cs
ActionJumpTo.cs

src/ActionsInterval/ActionBezierAbs.cs

@@ -4,10 +4,10 @@ using UnityEngine;
 
 class ActionBezierAbs : ActionInterval
 {
-    public Vector3 startPoint;
-    public Vector3 endPoint;
-    public Vector3 startControlPoint;
-    public Vector3 endControlPoint;
+    protected Vector3 startPoint;
+    protected Vector3 endPoint;
+    protected Vector3 startControlPoint;
+    protected Vector3 endControlPoint;
 
     public ActionBezierAbs(Vector3 tgtStart, Vector3 tgtSCP, Vector3 tgtECP, Vector3 tgtEnd, float tgtDuration)
         : base(tgtDuration)
@@ -28,11 +28,6 @@ class ActionBezierAbs : ActionInterval
         return new ActionBezierAbs(endPoint, endControlPoint, startControlPoint, startPoint, duration);
     }
 
-    public override void start()
-    {
-        base.start();
-    }
-
     public override void stepInterval(float dt)
     {
         float t = timer / duration;
@@ -40,6 +35,6 @@ class ActionBezierAbs : ActionInterval
             + 3 * (startControlPoint - endControlPoint) + endPoint) * t
             + (3 * (startPoint + endControlPoint) - 6 * startControlPoint)) * t +
             3 * (startControlPoint - startPoint)) * t + startPoint;
-        target.gameObject.transform.position = newPosition;
+        transform.position = newPosition;
     }
 }

src/ActionsInterval/ActionBezierRel.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+class ActionBezierRel : ActionInterval
+{
+    protected Vector3 ep;
+    protected Vector3 cp1;
+    protected Vector3 cp2;
+    protected Vector3 startPoint;
+    protected Vector3 endPoint;
+    protected Vector3 startControlPoint;
+    protected Vector3 endControlPoint;
+
+    public ActionBezierRel(Vector3 tgtSCP, Vector3 tgtECP, Vector3 tgtEnd, float tgtDuration)
+        : base(tgtDuration)
+    {
+        ep = tgtEnd;
+        cp1 = tgtSCP;
+        cp2 = tgtECP;
+    }
+
+    public override Action clone()
+    {
+        return new ActionBezierRel(startControlPoint, endControlPoint, endPoint, duration);
+    }
+
+    public override Action reverse()
+    {
+        return new ActionBezierRel(-startControlPoint, -endControlPoint, -endPoint, duration);
+    }
+
+    public override void start()
+    {
+        base.start();
+        startPoint = target.transform.position;
+        endPoint = startPoint + ep;
+        startControlPoint = startPoint + cp1;
+        endControlPoint = startControlPoint + cp2;
+    }
+
+    public override void stepInterval(float dt)
+    {
+        float t = timer / duration;
+        Vector3 newPosition = (((-startPoint
+            + 3 * (startControlPoint - endControlPoint) + endPoint) * t
+            + (3 * (startPoint + endControlPoint) - 6 * startControlPoint)) * t +
+            3 * (startControlPoint - startPoint)) * t + startPoint;
+        transform.position = newPosition;
+    }
+}

src/ActionsInterval/ActionBlink.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+class ActionBlink : ActionRepeat
+{
+    protected bool randomDelay;
+    protected ActionDelay delay = new ActionDelay(0);
+    protected Action[] blinkSeq;
+
+    public ActionBlink(int tgtBlinks, float tgtDuration)
+        : base(null, tgtBlinks)
+    {
+        duration = tgtDuration;
+        count = (tgtBlinks) * 2;
+        blinkSeq = new Action[]
+        {
+            new ActionToggleVisibility(),
+            new ActionDelay(tgtDuration / tgtBlinks)
+        };
+        action = new ActionSequence(blinkSeq);
+    }
+
+    public override Action clone()
+    {
+        return new ActionBlink(count / 2 - 1, duration);
+    }
+
+    public override Action reverse()
+    {
+        return new ActionBlink(count / 2 - 1, duration);
+    }
+}

src/ActionsInterval/ActionFadeBy.cs

@@ -4,7 +4,7 @@ using UnityEngine;
 
 class ActionFadeBy : ActionInterval
 {
-    public float delta;
+    protected float delta;
 
     public ActionFadeBy(float tgtDelta, float tgtDuration)
         : base(tgtDuration)
@@ -25,8 +25,8 @@ class ActionFadeBy : ActionInterval
     public override void stepInterval(float dt)
     {
         float d = dt / duration;
-        Color tgtColor = target.gameObject.renderer.material.color;
+        Color tgtColor = renderer.material.color;
         tgtColor[3] += delta * d;
-        target.gameObject.renderer.material.color = tgtColor;
+        renderer.material.color = tgtColor;
     }
 }

src/ActionsInterval/ActionFadeTo.cs

@@ -4,8 +4,8 @@ using UnityEngine;
 
 class ActionFadeTo : ActionInterval
 {
-    public float value;
-    public float delta;
+    protected float value;
+    protected float delta;
 
     public ActionFadeTo(float tgtValue, float tgtDuration)
         : base(tgtDuration)
@@ -21,14 +21,14 @@ class ActionFadeTo : ActionInterval
     public override void start()
     {
         base.start();
-        delta = value - target.gameObject.renderer.material.color.a;
+        delta = value - renderer.material.color.a;
     }
 
     public override void stepInterval(float dt)
     {
         float d = dt / duration;
-        Color tgtColor = target.gameObject.renderer.material.color;
+        Color tgtColor = renderer.material.color;
         tgtColor[3] += delta * d;
-        target.gameObject.renderer.material.color = tgtColor;
+        renderer.material.color = tgtColor;
     }
 }

src/ActionsInterval/ActionJumpBy.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+class ActionJumpBy : ActionSequence
+{
+    protected Vector3 point;
+    float height;
+    int jumps;
+
+    public ActionJumpBy(Vector3 tgtPoint, float tgtHeight, int tgtJumps, float tgtDuration)
+        : base(new Action[tgtJumps])
+    {
+        point = tgtPoint;
+        jumps = tgtJumps;
+        height = tgtHeight;
+        duration = tgtDuration;
+    }
+
+    public override Action clone()
+    {
+        return new ActionJumpBy(point, height, jumps, duration);
+    }
+
+    public override Action reverse()
+    {
+        return new ActionJumpBy(-point, height, jumps, duration);
+    }
+
+    public override void start()
+    {
+        float coeff = 1F / jumps;
+        Vector3 end = point * coeff;
+        Vector3 cp1 = Vector3.up * height;
+        Vector3 cp2 = end + cp1;
+        ActionBezierRel singleJump = new ActionBezierRel(cp1, cp2, end, duration * coeff);
+        for (int i = 0; i < jumps; i++)
+        {
+            actions[i] = singleJump;
+        }
+        base.start();
+    }
+}

src/ActionsInterval/ActionJumpTo.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+class ActionJumpTo : ActionSequence
+{
+    protected Vector3 point;
+    float height;
+    int jumps;
+
+    public ActionJumpTo(Vector3 tgtPoint, float tgtHeight, int tgtJumps, float tgtDuration)
+        : base(new Action[tgtJumps])
+    {
+        point = tgtPoint;
+        jumps = tgtJumps;
+        height = tgtHeight;
+        duration = tgtDuration;
+    }
+
+    public override Action clone()
+    {
+        return new ActionJumpTo(point, height, jumps, duration);
+    }
+
+    public override void start()
+    {
+        float coeff = 1F / jumps;
+        Vector3 start = target.gameObject.transform.position;
+        Vector3 end = (point - start) * coeff;
+        Vector3 cp1 = Vector3.up * height;
+        Vector3 cp2 = end + cp1;
+        ActionBezierRel singleJump = new ActionBezierRel(cp1, cp2, end, duration * coeff);
+        for (int i = 0; i < jumps; i++)
+        {
+            actions[i] = singleJump;
+        }
+        base.start();
+    }
+}

src/ActionsInterval/ActionMoveBy.cs

@@ -26,6 +26,6 @@ class ActionMoveBy : ActionInterval
     {
         float d = dt / duration;
         Vector3 tgt = delta * d;
-        target.gameObject.transform.Translate(tgt, Space.World);
+        transform.Translate(tgt, Space.World);
     }
 }

src/ActionsInterval/ActionMoveTo.cs

@@ -22,13 +22,13 @@ class ActionMoveTo : ActionInterval
     public override void start()
     {
         base.start();
-        path = value - target.gameObject.transform.position;
+        path = value - transform.position;
     }
 
     public override void stepInterval(float dt)
     {
         float d = dt / duration;
         Vector3 tgt = path * d;
-        target.gameObject.transform.Translate(tgt, Space.World);
+        transform.Translate(tgt, Space.World);
     }
 }

src/ActionsInterval/ActionRotateBy.cs

@@ -26,8 +26,8 @@ class ActionRotateBy : ActionInterval
     {
         float d = dt / duration;
         Vector3 tgt = delta * d;
-        target.gameObject.transform.Rotate(Vector3.up, tgt.y);
-        target.gameObject.transform.Rotate(Vector3.right, tgt.x);
-        target.gameObject.transform.Rotate(Vector3.forward, tgt.z);
+        transform.Rotate(Vector3.up, tgt.y);
+        transform.Rotate(Vector3.right, tgt.x);
+        transform.Rotate(Vector3.forward, tgt.z);
     }
 }

src/ActionsInterval/ActionRotateTo.cs

@@ -25,7 +25,7 @@ class ActionRotateTo : ActionInterval
         for (int i = 0; i < 3; i++)
         {
             float t = value[i];
-            float f = target.gameObject.transform.rotation.eulerAngles[i];
+            float f = transform.rotation.eulerAngles[i];
             if (Math.Abs(t - f) < Math.Abs(t + 360 - f))
                 path[i] = t - f;
             else
@@ -36,8 +36,8 @@ class ActionRotateTo : ActionInterval
     {
         float d = dt / duration;
         Vector3 tgt = path * d;
-        target.gameObject.transform.Rotate(Vector3.up, tgt.y);
-        target.gameObject.transform.Rotate(Vector3.right, tgt.x);
-        target.gameObject.transform.Rotate(Vector3.forward, tgt.z);
+        transform.Rotate(Vector3.up, tgt.y);
+        transform.Rotate(Vector3.right, tgt.x);
+        transform.Rotate(Vector3.forward, tgt.z);
     }
 }

src/ActionsInterval/ActionScaleBy.cs

@@ -26,18 +26,18 @@ class ActionScaleBy : ActionInterval
     public override void start()
     {
         base.start();
-        Vector3 scale = target.gameObject.transform.localScale;
+        Vector3 scale = transform.localScale;
         scale.x *= delta.x;
         scale.y *= delta.y;
         scale.z *= delta.z;
-        path = scale - target.gameObject.transform.localScale;
+        path = scale - transform.localScale;
     }
 
     public override void stepInterval(float dt)
     {
         float d = dt / duration;
         Vector3 tgt = path * d;
-        target.gameObject.transform.localScale += tgt;
+        transform.localScale += tgt;
     }
 
     public override void stop()

src/ActionsInterval/ActionScaleTo.cs

@@ -21,14 +21,14 @@ class ActionScaleTo : ActionInterval
     public override void start()
     {
         base.start();
-        path = value - target.gameObject.transform.localScale;
+        path = value - transform.localScale;
     }
 
     public override void stepInterval(float dt)
     {
         float d = dt / duration;
         Vector3 tgt = path * d;
-        target.gameObject.transform.localScale += tgt;
+        transform.localScale += tgt;
     }
 
     public override void stop()

src/ActionsInterval/ActionTintBy.cs

@@ -4,7 +4,7 @@ using UnityEngine;
 
 class ActionTintBy : ActionInterval
 {
-    public Vector4 color;
+    protected Vector4 color;
     protected const float coeff = 1F / 255F;
 
     public ActionTintBy(Vector4 tgtColor, float tgtDuration)
@@ -32,11 +32,11 @@ class ActionTintBy : ActionInterval
     {
         float d = dt / duration;
         Vector4 tgt = color * d;
-        Color tgtColor = target.gameObject.renderer.material.color;
+        Color tgtColor = renderer.material.color;
         tgtColor[0] += tgt[0];
         tgtColor[1] += tgt[1];
         tgtColor[2] += tgt[2];
         tgtColor[3] += tgt[3];
-        target.gameObject.renderer.material.color = tgtColor;
+        renderer.material.color = tgtColor;
     }
 }

src/ActionsInterval/ActionTintTo.cs

@@ -4,8 +4,8 @@ using UnityEngine;
 
 class ActionTintTo : ActionInterval
 {
-    public Vector4 color;
-    public Vector4 path;
+    protected Vector4 color;
+    protected Vector4 path;
     protected const float coeff = 1F / 255F;
 
     public ActionTintTo(Vector4 tgtColor, float tgtDuration)
@@ -28,7 +28,7 @@ class ActionTintTo : ActionInterval
     public override void start()
     {
         base.start();
-        Color tgtColor = target.gameObject.renderer.material.color;
+        Color tgtColor = renderer.material.color;
         path[0] = color[0] - tgtColor[0];
         path[1] = color[1] - tgtColor[1];
         path[2] = color[2] - tgtColor[2];
@@ -39,11 +39,11 @@ class ActionTintTo : ActionInterval
     {
         float d = dt / duration;
         Vector4 tgt = path * d;
-        Color tgtColor = target.gameObject.renderer.material.color;
+        Color tgtColor = renderer.material.color;
         tgtColor[0] += tgt[0];
         tgtColor[1] += tgt[1];
         tgtColor[2] += tgt[2];
         tgtColor[3] += tgt[3];
-        target.gameObject.renderer.material.color = tgtColor;
+        renderer.material.color = tgtColor;
     }
 }