Membrane stretch

simulation_parameters/Constants.cs

@@ -208,6 +208,10 @@ public static class Constants
     public const float MEMBRANE_WAVE_HEIGHT_MULTIPLIER_CELL_WALL = 0.015f;
     public const float MEMBRANE_ENGULF_ANIMATION_DISTANCE = 1.25f;
 
+    public const float MEMBRANE_MIDDLE_POINT_OVERREACH = 0.5f;
+    public const float MEMBRANE_NEIGHBOUR_MAX_DISTANCE_BETWEEN_CENTERS = 750.0f;
+    public const float MEMBRANE_NEIGHBOUR_MAX_DISTANCE_BETWEEN_VERTICES = 150.0f;
+
     /// <summary>
     ///   BASE MOVEMENT ATP cost. Cancels out a little bit more then one cytoplasm's glycolysis
     /// </summary>

src/microbe_stage/IMembraneDataSource.cs

@@ -10,25 +10,57 @@ public interface IMembraneDataSource
 {
     public Vector2[] HexPositions { get; }
     public int HexPositionCount { get; }
+    public Vector2[]? MulticellularPositions { get; }
+    public Vector2? CellPositionInMulticellular { get; }
+    public int[]? MulticellularOrientations { get; }
+    public int? CellOrientation { get; }
+    public long? ColonyKey { get; }
     public MembraneType Type { get; }
+    public bool IsPreMulticellularStretch { get; }
 }
 
 /// <summary>
 ///   Struct that holds parameters about a membrane generation request
 /// </summary>
 public struct MembraneGenerationParameters : IMembraneDataSource
 {
+    public MembraneGenerationParameters(Vector2[] hexPositions, int hexPositionCount, MembraneType type,
+        Vector2[] multicellularPositions, Vector2 thisCellPosition, int[]? multicellularOrientations,
+        int? thisCellOrientation, long? colonyKey = null, bool isPreMulticellularStretch = false)
+        : this(hexPositions, hexPositionCount, type)
+    {
+        MulticellularPositions = multicellularPositions;
+        CellPositionInMulticellular = thisCellPosition;
+        MulticellularOrientations = multicellularOrientations;
+        CellOrientation = thisCellOrientation;
+        ColonyKey = colonyKey;
+        IsPreMulticellularStretch = isPreMulticellularStretch;
+    }
+
     public MembraneGenerationParameters(Vector2[] hexPositions, int hexPositionCount, MembraneType type)
     {
         HexPositions = hexPositions;
         HexPositionCount = hexPositionCount;
         Type = type;
     }
 
+    public int[]? MulticellularOrientations { get; }
+
+    public int? CellOrientation { get; }
+
+    public long? ColonyKey { get; }
+
     public Vector2[] HexPositions { get; }
+
+    public Vector2[]? MulticellularPositions { get; }
+
+    public Vector2? CellPositionInMulticellular { get; }
+
     public int HexPositionCount { get; }
 
     public MembraneType Type { get; }
+
+    public bool IsPreMulticellularStretch { get; set; }
 }
 
 /// <summary>
@@ -89,7 +121,7 @@ public static MembranePointData GetOrComputeMembraneShape(IReadOnlyList<IPositio
 
         var cache = ProceduralDataCache.Instance;
 
-        var hash = ComputeMembraneDataHash(hexes, length, membraneType);
+        var hash = new MembraneGenerationParameters(hexes, length, membraneType).ComputeMembraneDataHash();
 
         var result = cache.ReadMembraneData(hash);
 
@@ -105,63 +137,151 @@ public static MembranePointData GetOrComputeMembraneShape(IReadOnlyList<IPositio
         // Need to compute the data now, it doesn't exist in the cache
         var generator = MembraneShapeGenerator.GetThreadSpecificGenerator();
 
-        result = generator.GenerateShape(hexes, length, membraneType);
+        result = generator.GenerateMicrobeShape(hexes, length, membraneType);
 
         cache.WriteMembraneData(ref result);
         return result;
     }
 
-    public static long ComputeMembraneDataHash(Vector2[] positions, int count, MembraneType type)
+    public static long ComputeMembraneDataHash(this IMembraneDataSource dataSource)
     {
-        var nameHash = type.InternalName.GetHashCode();
+        const long prime1 = 1099511628211L;
+        const long prime2 = 1409;
+        const long prime3 = 7793;
+
+        var nameHash = dataSource.Type.InternalName.GetHashCode();
 
         unchecked
         {
-            long hash = 1409 + nameHash + ((long)nameHash << 28);
+            long hash = prime2 + nameHash + ((long)nameHash << 28);
+
+            hash ^= (dataSource.HexPositionCount + 1) * prime3;
+
+            for (int i = 0; i < dataSource.HexPositionCount; ++i)
+            {
+                hash = (hash * prime1) ^ BitConverter.SingleToInt32Bits(dataSource.HexPositions[i].X);
+                hash = (hash * prime1) ^ BitConverter.SingleToInt32Bits(dataSource.HexPositions[i].Y);
+            }
 
-            hash ^= (count + 1) * 7793;
-            int hashMultiply = 1;
+            // NOTE: ColonyKey alone is the same for every cell in a colony, so it cannot be the only thing
+            // distinguishing membrane data between cells that share a hex layout. The per-cell position/orientation
+            // must also be part of the hash.
+            if (dataSource.CellPositionInMulticellular != null)
+            {
+                hash = (hash * prime1) ^
+                    BitConverter.SingleToInt32Bits(dataSource.CellPositionInMulticellular.Value.X);
+                hash = (hash * prime1) ^
+                    BitConverter.SingleToInt32Bits(dataSource.CellPositionInMulticellular.Value.Y);
+            }
+
+            if (dataSource.CellOrientation != null)
+            {
+                hash = (hash * prime1) ^ dataSource.CellOrientation.Value;
+            }
 
-            for (int i = 0; i < count; ++i)
+            if (dataSource.ColonyKey != null)
             {
-                var posHash = positions[i].GetHashCode();
+                hash = (hash * prime1) ^ dataSource.ColonyKey.Value;
+            }
 
-                // TODO: switch to using rotate left here once we can (after Godot 4)
-                hash ^= (hashMultiply * posHash) ^ ((5081L * hashMultiply * hashMultiply + posHash) << 32);
-                ++hashMultiply;
+            if (dataSource.IsPreMulticellularStretch)
+            {
+                hash = (hash * prime1) ^ 1;
             }
 
             return hash;
         }
     }
 
-    public static long ComputeMembraneDataHash(this IMembraneDataSource dataSource)
-    {
-        return ComputeMembraneDataHash(dataSource.HexPositions, dataSource.HexPositionCount, dataSource.Type);
-    }
-
     public static bool MembraneDataFieldsEqual(this IMembraneDataSource dataSource, IMembraneDataSource other)
     {
-        return dataSource.MembraneDataFieldsEqual(other.HexPositions, other.HexPositionCount, other.Type);
+        return dataSource.MembraneDataFieldsEqual(other.HexPositions, other.HexPositionCount, other.Type,
+            other.CellPositionInMulticellular, other.CellOrientation, other.ColonyKey);
     }
 
     public static bool MembraneDataFieldsEqual(this IMembraneDataSource dataSource, Vector2[] otherPoints,
-        int otherPointCount, MembraneType otherType)
+        int otherPointCount, MembraneType otherType, Vector2? cellPositionInMulticellular = null,
+        int? cellOrientationInMulticellular = null, long? otherColonyKey = null)
     {
         if (!dataSource.Type.Equals(otherType))
+        {
+            GD.PrintErr($"Membrane cache Type mismatch: {dataSource.Type} != {otherType}");
             return false;
+        }
 
         if (dataSource.HexPositionCount != otherPointCount)
+        {
+            GD.PrintErr("Membrane cache HexPositionCount mismatch: " +
+                $"{dataSource.HexPositionCount} != {otherPointCount}");
             return false;
+        }
 
         var count = dataSource.HexPositionCount;
 
         var sourcePoints = dataSource.HexPositions;
 
+        // Per-cell position must match — this is what actually distinguishes cells within the same colony
+        if (dataSource.CellPositionInMulticellular != null || cellPositionInMulticellular != null)
+        {
+            if (dataSource.CellPositionInMulticellular == null || cellPositionInMulticellular == null)
+            {
+                GD.PrintErr("Membrane cache CellPositionInMulticellular null mismatch: " +
+                    $"source={dataSource.CellPositionInMulticellular == null} " +
+                    $"other={cellPositionInMulticellular == null}");
+                return false;
+            }
+
+            if (!dataSource.CellPositionInMulticellular.Value.Equals(cellPositionInMulticellular.Value))
+            {
+                GD.PrintErr("Membrane cache CellPositionInMulticellular mismatch: " +
+                    $"{dataSource.CellPositionInMulticellular} != {cellPositionInMulticellular}");
+                return false;
+            }
+        }
+
+        if (dataSource.CellOrientation != null || cellOrientationInMulticellular != null)
+        {
+            if (dataSource.CellOrientation == null || cellOrientationInMulticellular == null)
+            {
+                GD.PrintErr("Membrane cache CellOrientation null mismatch: " +
+                    $"source={dataSource.CellOrientation == null} " +
+                    $"other={cellOrientationInMulticellular == null}");
+                return false;
+            }
+
+            if (dataSource.CellOrientation.Value != cellOrientationInMulticellular.Value)
+            {
+                GD.PrintErr("Membrane cache CellOrientation mismatch: " +
+                    $"{dataSource.CellOrientation} != {cellOrientationInMulticellular}");
+                return false;
+            }
+        }
+
+        if (dataSource.ColonyKey != null || otherColonyKey != null)
+        {
+            if (dataSource.ColonyKey == null || otherColonyKey == null)
+            {
+                GD.PrintErr("Membrane cache ColonyKey null mismatch: " +
+                    $"source={dataSource.ColonyKey == null} other={otherColonyKey == null}");
+                return false;
+            }
+
+            if (dataSource.ColonyKey.Value != otherColonyKey.Value)
+            {
+                GD.PrintErr(
+                    $"Membrane cache ColonyKey mismatch: {dataSource.ColonyKey.Value} != {otherColonyKey.Value}");
+                return false;
+            }
+        }
+
         for (int i = 0; i < count; ++i)
         {
             if (sourcePoints[i] != otherPoints[i])
+            {
+                GD.PrintErr($"Membrane cache HexPositions[{i}] mismatch: " +
+                    $"{sourcePoints[i]} != {otherPoints[i]}");
                 return false;
+            }
         }
 
         return true;