New 'LoopNoPause' mode and 'easing' option

Author: maddie480

Ahorn/entities/multiNodeMovingPlatform.jl

@@ -2,12 +2,12 @@ module SpringCollab2020MultiNodeMovingPlatform
 
 using ..Ahorn, Maple
 
-@pardef MultiNodeMovingPlatform(x::Integer, y::Integer, width::Integer=Maple.defaultBlockWidth, mode::String="Loop", texture::String="default", moveTime::Number=2.0, pauseTime::Number=0.0) =
-    Entity("SpringCollab2020/MultiNodeMovingPlatform", x=x, y=y, nodes=Tuple{Int, Int}[], width=width, mode=mode, texture=texture, moveTime=moveTime, pauseTime=pauseTime)
+@pardef MultiNodeMovingPlatform(x::Integer, y::Integer, width::Integer=Maple.defaultBlockWidth, mode::String="Loop", texture::String="default", moveTime::Number=2.0, pauseTime::Number=0.0, easing::Bool=true) =
+    Entity("SpringCollab2020/MultiNodeMovingPlatform", x=x, y=y, nodes=Tuple{Int, Int}[], width=width, mode=mode, texture=texture, moveTime=moveTime, pauseTime=pauseTime, easing=easing)
 
 const placements = Ahorn.PlacementDict()
 
-const modes = ["Loop", "BackAndForth", "BackAndForthNoPause", "TeleportBack"]
+const modes = ["Loop", "LoopNoPause", "BackAndForth", "BackAndForthNoPause", "TeleportBack"]
 
 for texture in Maple.wood_platform_textures
     placements["Platform (Moving, Multi-Node, $(uppercasefirst(texture))) (Spring Collab 2020)"] = Ahorn.EntityPlacement(
@@ -115,7 +115,7 @@ function Ahorn.renderAbs(ctx::Ahorn.Cairo.CairoContext, entity::MultiNodeMovingP
         previousNodeX, previousNodeY = nodeX, nodeY
     end
 
-    if mode == "Loop"
+    if mode == "Loop" || mode == "LoopNoPause"
         renderConnection(ctx, previousNodeX, previousNodeY, firstNodeX, firstNodeY, width)
     end
 
@@ -139,7 +139,7 @@ function Ahorn.renderSelectedAbs(ctx::Ahorn.Cairo.CairoContext, entity::MultiNod
         previousNodeX, previousNodeY = nodeX, nodeY
     end
 
-    if mode == "Loop"
+    if mode == "Loop" || mode == "LoopNoPause"
         Ahorn.drawArrow(ctx, previousNodeX + width / 2, previousNodeY, firstNodeX + width / 2, firstNodeY, Ahorn.colors.selection_selected_fc, headLength=6)
     end
 end

Ahorn/lang/en_gb.lang

@@ -131,5 +131,6 @@ placements.triggers.SpringCollab2020/CustomBirdTutorialTrigger.tooltips.showTuto
 # Multi-Node Moving Platform
 placements.entities.SpringCollab2020/MultiNodeMovingPlatform.tooltips.moveTime=The time the platform takes to move between two successive positions. Default is 2 seconds.
 placements.entities.SpringCollab2020/MultiNodeMovingPlatform.tooltips.pauseTime=The time the platform stops at each position. Default is 0 seconds.
-placements.entities.SpringCollab2020/MultiNodeMovingPlatform.tooltips.mode=Determines the way the platform will move between its nodes. For example, with 3 nodes A, B, C:\n- Loop: A > B > C > A\n- BackAndForth: A > B > C > B > A\n- BackAndForthNoPause: A > C > A (going through B)\n- TeleportBack: A > B > C, then the platform teleports to A upon reaching C
+placements.entities.SpringCollab2020/MultiNodeMovingPlatform.tooltips.mode=Determines the way the platform will move between its nodes. For example, with 3 nodes A, B, C:\n- Loop: A > B > C > A\n- LoopNoPause: A > A (going through B and C)\n- BackAndForth: A > B > C > B > A\n- BackAndForthNoPause: A > C > A (going through B)\n- TeleportBack: A > B > C, then the platform teleports to A upon reaching C
 placements.entities.SpringCollab2020/MultiNodeMovingPlatform.tooltips.texture=What texture to use for the platform.
+placements.entities.SpringCollab2020/MultiNodeMovingPlatform.tooltips.easing=Whether the platform movement should be eased (speedup/slowdown around each position).

Entities/MultiNodeMovingPlatform.cs

@@ -7,7 +7,7 @@ namespace Celeste.Mod.SpringCollab2020.Entities {
     [CustomEntity("SpringCollab2020/MultiNodeMovingPlatform")]
     class MultiNodeMovingPlatform : JumpThru {
         private enum Mode {
-            BackAndForth, BackAndForthNoPause, Loop, TeleportBack
+            BackAndForth, BackAndForthNoPause, Loop, LoopNoPause, TeleportBack
         }
 
         // settings
@@ -16,8 +16,10 @@ private enum Mode {
         private float pauseTime;
         private string overrideTexture;
         private Mode mode;
+        private bool easing;
 
         private MTexture[] textures;
+        private float[] nodePercentages;
 
         private string lastSfx;
         private SoundSource sfx;
@@ -39,8 +41,9 @@ public MultiNodeMovingPlatform(EntityData data, Vector2 offset)
             // read attributes
             moveTime = data.Float("moveTime", 2f);
             pauseTime = data.Float("pauseTime");
-            overrideTexture = data.Attr("texture");
-            mode = data.Enum<Mode>("mode");
+            overrideTexture = data.Attr("texture", "default");
+            mode = data.Enum("mode", Mode.Loop);
+            easing = data.Bool("easing", true);
 
             // read nodes
             nodes = new Vector2[data.Nodes.Length + 1];
@@ -56,6 +59,30 @@ public MultiNodeMovingPlatform(EntityData data, Vector2 offset)
                 "event:/game/03_resort/platform_horiz_left" : "event:/game/03_resort/platform_horiz_right";
 
             Add(new LightOcclude(0.2f));
+
+            if (mode == Mode.BackAndForthNoPause || mode == Mode.LoopNoPause) {
+                nodePercentages = new float[mode == Mode.LoopNoPause ? nodes.Length : nodes.Length - 1];
+                float totalDistance = 0;
+
+                // compute the distance between each node.
+                for (int i = 0; i < nodes.Length - 1; i++) {
+                    float distance = Vector2.Distance(nodes[i], nodes[i + 1]);
+                    nodePercentages[i] = totalDistance + distance;
+                    totalDistance += distance;
+                }
+
+                // if looping, also compute the distance between the last node and the first one.
+                if (mode == Mode.LoopNoPause) {
+                    float distance = Vector2.Distance(nodes[nodes.Length - 1], nodes[0]);
+                    nodePercentages[nodes.Length - 1] = totalDistance + distance;
+                    totalDistance += distance;
+                }
+
+                // turn them into percentages.
+                for (int i = 0; i < nodePercentages.Length; i++) {
+                    nodePercentages[i] /= totalDistance;
+                }
+            }
         }
 
         public override void Added(Scene scene) {
@@ -79,7 +106,7 @@ public override void Added(Scene scene) {
                     scene.Add(new MovingPlatformLine(nodes[i] + lineOffset, nodes[i + 1] + lineOffset));
                 }
 
-                if (mode == Mode.Loop) {
+                if (mode == Mode.Loop || mode == Mode.LoopNoPause) {
                     scene.Add(new MovingPlatformLine(nodes[nodes.Length - 1] + lineOffset, nodes[0] + lineOffset));
                 }
             }
@@ -132,25 +159,45 @@ public override void Update() {
                 // move forward...
                 percent = Calc.Approach(percent, 1f, Engine.DeltaTime / moveTime);
 
-                if (mode == Mode.BackAndForthNoPause) {
+                if (mode == Mode.BackAndForthNoPause || mode == Mode.LoopNoPause) {
+                    // NO PAUSE MODES: the "percentage" is the progress for the whole track, including all nodes.
+
                     if (percent == 1f) {
                         // we reached the last node.
-                        prevNodeIndex = direction == 1 ? nodes.Length - 1 : 0;
-                        MoveTo(nodes[prevNodeIndex] + new Vector2(0f, addY));
-
-                        // go the other way round now.
-                        direction = -direction;
+                        // pause, then start over.
                         percent = 0f;
                         pauseTimer = pauseTime;
+
+                        if (mode == Mode.BackAndForthNoPause) {
+                            // the current node we're stopped at is either the last node, or the first one, depending on the direction.
+                            prevNodeIndex = direction == 1 ? nodes.Length - 1 : 0;
+
+                            // go the other way round now.
+                            direction = -direction;
+                        }
+
+                        MoveTo(nodes[prevNodeIndex] + new Vector2(0f, addY));
                     } else {
-                        // compute global progress among all nodes, then lerp between the two right nodes.
-                        float progress = MathHelper.Lerp(0, nodes.Length - 1, Ease.SineInOut(direction == 1 ? percent : 1 - percent));
-                        int nodeIndex = (int) progress;
-                        MoveTo(Vector2.Lerp(nodes[nodeIndex], nodes[nodeIndex + 1], progress - nodeIndex) + new Vector2(0f, addY));
+                        // OTHER MODES: the "percentage" is the progress between the current node and the next one.
+
+                        float easedPercentage = applyEase(direction == 1 ? percent : 1 - percent);
+
+                        // for example, if node percentages are 0.2 and 1, and easedPercentage is 0.6, nextNodeIndex = 1.
+                        int nextNodeIndex = 0;
+                        while (nodePercentages[nextNodeIndex] < easedPercentage) {
+                            nextNodeIndex++;
+                        }
+
+                        // in this case, previousNodePercentage = 0.2 and nextNodePercentage = 1. ClampedMap will remap 0.6 to 0.5 since this is halfway between 0.2 and 1.
+                        float previousNodePercentage = nextNodeIndex == 0 ? 0 : nodePercentages[nextNodeIndex - 1];
+                        float nextNodePercentage = nodePercentages[nextNodeIndex];
+
+                        MoveTo(Vector2.Lerp(nodes[nextNodeIndex], nodes[(nextNodeIndex + 1) % nodes.Length],
+                            Calc.ClampedMap(easedPercentage, previousNodePercentage, nextNodePercentage)) + new Vector2(0f, addY));
                     }
                 } else {
                     // lerp between the previous node and the next one.
-                    MoveTo(Vector2.Lerp(nodes[prevNodeIndex], nodes[nextNodeIndex], Ease.SineInOut(percent)) + new Vector2(0f, addY));
+                    MoveTo(Vector2.Lerp(nodes[prevNodeIndex], nodes[nextNodeIndex], applyEase(percent)) + new Vector2(0f, addY));
 
                     if (percent == 1f) {
                         // reached the end. start waiting before moving again, and switch the target to the next node.
@@ -181,5 +228,16 @@ public override void Update() {
                 }
             }
         }
+
+        /// <summary>
+        /// Apply easing if the "easing" attribute is true, else don't modify the value.
+        /// </summary>
+        private float applyEase(float rawValue) {
+            if (easing) {
+                return Ease.SineInOut(rawValue);
+            }
+
+            return rawValue;
+        }
     }
 }