fix: virtual grid-snapped tail anchor prevents corner diagonals

Body path now goes: interp_tail → grid_tail → segment[N-2] → ... → head.
The short leg from interpolated to grid-snapped tail is always straight
(same direction), and from grid_tail onward the path strictly follows
the grid — preserving sharp corners while tail stays smooth.

Snake.Avalonia/Views/AnimationHelper.cs

@@ -26,7 +26,16 @@ public static class AnimationHelper
     }
 
     /// <summary>
-    /// Interpolates between two positions with given t value.
+    /// Ease-in cubic — mirror of EaseOutCubic, for tail interpolation.
+    /// </summary>
+    public static double EaseInCubic(double t)
+    {
+        t = Math.Clamp(t, 0.0, 1.0);
+        return t * t * t;
+    }
+
+    /// <summary>
+    /// Interpolates between two positions with given t value and easing mode.
     /// Returns the visual position for rendering.
     /// </summary>
     public static (double X, double Y) InterpolatePosition(
@@ -34,9 +43,14 @@ public static class AnimationHelper
         Position to,
         double t,
         double cellSize,
-        bool useEasing = false)
+        string easing = "linear")
     {
-        var eased = useEasing ? EaseOutCubic(t) : t;
+        var eased = easing switch
+        {
+            "easeOut" => EaseOutCubic(t),
+            "easeIn" => EaseInCubic(t),
+            _ => t
+        };
         var x = from.X + (to.X - from.X) * eased;
         var y = from.Y + (to.Y - from.Y) * eased;
         return (x * cellSize + cellSize * 0.5, y * cellSize + cellSize * 0.5);

Snake.Avalonia/Views/SnakeRenderer.cs

@@ -133,53 +133,42 @@ public sealed class SnakeRenderer : Control
 
         var t = InterpolationT;
         var segmentsList = Segments;
-        var prevList = PreviousSegments;
+        var count = segmentsList.Count;
 
-        // Build path for body (all segments except head)
+        // === Body path: from interp tail → grid tail (virtual corner anchor) → body → head ===
-        var bodyGeometry = new StreamGeometry();
+        // The virtual grid-snapped tail prevents diagonal shortcuts at corners:
-        using (var ctx = bodyGeometry.Open())
+        // the short leg from interp_tail to grid_tail is always straight (same direction),
+        // and from grid_tail onward the path strictly follows the grid.
+        if (count >= 2)
         {
-            for (var i = segmentsList.Count - 1; i >= 1; i--)
+            var bodyGeometry = new StreamGeometry();
+            using (var ctx = bodyGeometry.Open())
             {
-                var current = segmentsList[i];
+                // Start at interpolated tail
-                var (vx, vy) = GetVisualPosition(current, i, t);
+                var (tailX, tailY) = GetVisualPosition(segmentsList[count - 1], count - 1, t);
+                ctx.BeginFigure(new Point(tailX, tailY), false);
 
-                if (i == segmentsList.Count - 1 && segmentsList.Count > 2)
+                // Virtual corner anchor: grid-snapped tail position
-                {
+                var lastPos = segmentsList[count - 1];
-                    ctx.BeginFigure(new Point(vx, vy), false);
+                var (gridTailX, gridTailY) = (lastPos.X * CellSize + CellSize * 0.5, lastPos.Y * CellSize + CellSize * 0.5);
-                }
+                ctx.LineTo(new Point(gridTailX, gridTailY));
-                else if (i == segmentsList.Count - 1)
-                {
-                    ctx.BeginFigure(new Point(vx, vy), false);
-                }
 
-                // Draw line segment
+                // Draw through middle segments down to head
-                if (i > 1)
+                for (var i = count - 2; i >= 0; i--)
                 {
-                    var (px, py) = GetVisualPosition(segmentsList[i - 1], i - 1, t);
+                    var (px, py) = GetVisualPosition(segmentsList[i], i, t);
                     ctx.LineTo(new Point(px, py));
                 }
             }
 
-            if (segmentsList.Count >= 2)
+            // Body thickness
-            {
+            var maxThickness = CellSize * 0.7;
-                var (hx, hy) = GetVisualPosition(segmentsList[0], 0, t);
+            var bodyThickness = Math.Max(CellSize * 0.35, maxThickness * 0.85);
-                ctx.LineTo(new Point(hx, hy));
+            var bodyPen = new Pen(SnakeBodyBrush, bodyThickness,
-            }
+                lineCap: PenLineCap.Round, lineJoin: PenLineJoin.Round);
-        }
+            context.DrawGeometry(null, bodyPen, bodyGeometry);
 
-        // Calculate body thickness based on segment position (tail thinner)
+            // Inner highlight stroke
-        var maxThickness = CellSize * 0.7;
-        var minThickness = CellSize * 0.35;
-
-        // Draw body as a thick stroke
-        var bodyThickness = Math.Max(minThickness, maxThickness * 0.85);
-        var bodyPen = new Pen(SnakeBodyBrush, bodyThickness, lineCap: PenLineCap.Round, lineJoin: PenLineJoin.Round);
-        context.DrawGeometry(null, bodyPen, bodyGeometry);
-
-        // Draw a slightly thinner inner stroke for gradient effect
-        if (segmentsList.Count >= 2)
-        {
             var innerPen = new Pen(
                 new SolidColorBrush(SnakeHeadBrush.Color, 0.4),
                 bodyThickness * 0.5,
@@ -379,8 +368,7 @@ public sealed class SnakeRenderer : Control
         var isHead = segmentIndex == 0;
         var isTail = Segments.Count > 1 && segmentIndex == Segments.Count - 1;
 
-        // Only interpolate head and tail — middle segments stay grid-snapped
+        // Head and tail interpolate smoothly; middle segments stay grid-snapped
-        // to preserve sharp corners when the snake bends.
         if (!isHead && !isTail)
             return (pos.X * CellSize + CellSize * 0.5, pos.Y * CellSize + CellSize * 0.5);
 
@@ -388,7 +376,8 @@ public sealed class SnakeRenderer : Control
             ? AnimationHelper.GetPreviousPosition(segmentIndex, Segments, PreviousSegments, SnakeDirection)
             : pos;
 
-        // Head gets easing for snappy feel; tail uses linear interpolation
+        // Head: ease-out forward. Tail: ease-in backward (mirrored).
-        return AnimationHelper.InterpolatePosition(from, pos, t, CellSize, useEasing: isHead);
+        var easingMode = isHead ? "easeOut" : "easeIn";
+        return AnimationHelper.InterpolatePosition(from, pos, t, CellSize, easing: easingMode);
     }
 }