wild tiles can heal

gdd.md

@@ -11,15 +11,14 @@
 ## Clock
 
 Ticks can be applied manually or they can be applied over time.
-Add a tick counter as a UI element.
+There is a tick counter UI debug element.
 
-## Grid
+## Diffusion
+
+### Grid
 
 Add a 10x10 grid.
 Tiles are highlighted a different colour when the player hovers over them with the cursor.
-
-### Diffusion
-
 Tiles in the grid contain floating point values.
 These values propogate to neighbouring cells a tick happens.
 

half-earth/resources/tiles/tile_types/tile_type_collections/buildable_tiles.tres

@@ -1,8 +1,9 @@
-[gd_resource type="Resource" load_steps=3 format=2]
+[gd_resource type="Resource" load_steps=4 format=2]
 
 [ext_resource path="res://scripts/tile/TileTypeCollection.cs" type="Script" id=1]
 [ext_resource path="res://resources/tiles/tile_types/developed.tres" type="Resource" id=2]
+[ext_resource path="res://resources/tiles/tile_types/wild.tres" type="Resource" id=3]
 
 [resource]
 script = ExtResource( 1 )
-_resources = [ ExtResource( 2 ) ]
+_resources = [ ExtResource( 2 ), ExtResource( 3 ) ]

half-earth/resources/tiles/tile_types/wild.tres

@@ -8,4 +8,5 @@ Name = "Wild"
 Key = 87
 Color = Color( 0.14902, 1, 0, 0 )
 HeatGeneration = -0.02
+HealRate = 0.01
 Threshold = 0.6

half-earth/scripts/EnvironmentSystem.cs

@@ -1,13 +1,13 @@
 using Godot;
 
-public class HeatSystem
+public class EnvironmentSystem
 {
     private readonly TileGrid _tiles;
     private readonly float _diffusionCoefficient;
 
     private float[] _nextTemperatures = null;
 
-    public HeatSystem(TileGrid tiles, float diffusionCoefficient)
+    public EnvironmentSystem(TileGrid tiles, float diffusionCoefficient)
     {
         _tiles = tiles;
         _diffusionCoefficient = diffusionCoefficient;
@@ -20,7 +20,6 @@ public class HeatSystem
         Diffuse();
     }
 
-
     private float TransferHeat(float t0, float alpha, float nx, float ny, float px, float py)
     {
         float d2tdx2 = nx - 2 * t0 + px;
@@ -46,23 +45,42 @@ public class HeatSystem
             var tile = _tiles[i];
             var type = tile.type;
             tile.temperature += type.HeatGeneration;
-            ApplyHeatDamage(ref tile);
             _tiles[i] = tile;
         }
+
+        for (int i = 0; i < _tiles.Count; i++)
+        {
+            ApplyHeatDamage(i);
+        }
     }
 
-    private void ApplyHeatDamage(ref Tile tile)
+    private void ApplyHeatDamage(int i)
     {
+        _tiles.MapIndex(i, out var x, out var y);
+        var tile = _tiles[x, y];
         if (!(tile.type is IDamageable damageable))
             return;
 
-        var surplus = tile.temperature - damageable.Threshold;
+        var delta = tile.temperature - damageable.Threshold;
-        if (surplus < 0)
+        if (delta < 0)
-            return;
+        {
+            // we want to heal based on how many wild tiles surround us
+            float wild = _tiles.GetNeighbourProportion<Wild>(x, y);
+            float heal = damageable.HealRate * wild;
 
+            tile.currentHealth += heal;
+        }
+        else
+        {
             // TODO: parameterised balancing
-        tile.currentHealth -= surplus;
+
+            // take damage
+            tile.currentHealth -= delta;
+        }
+
         tile.currentHealth = Mathf.Clamp(tile.currentHealth, 0, 1);
+
+        _tiles[x, y] = tile;
     }
 
     private void Diffuse()
@@ -96,5 +114,4 @@ public class HeatSystem
             _tiles[i] = tile;
         }
     }
-
 }

half-earth/scripts/WorldGrid.cs

@@ -21,7 +21,7 @@ public class WorldGrid : Node2D
         public ShaderMaterial material;
     }
     private TileView[] _tileViews;
-    private HeatSystem _heat;
+    private EnvironmentSystem _environment;
 
     // Called when the node enters the scene tree for the first time.
     public override void _Ready()
@@ -30,7 +30,7 @@ public class WorldGrid : Node2D
 
         GenerateCanvasItems(_tileGrid);
 
-        _heat = new HeatSystem(_tileGrid, DiffusionCoefficient);
+        _environment = new EnvironmentSystem(_tileGrid, DiffusionCoefficient);
     }
 
     #region Positioning
@@ -53,6 +53,7 @@ public class WorldGrid : Node2D
 
         var tile = _tileGrid[idx];
         tile.type = tileType;
+        tile = tileType.ApplySpawneffect(tile);
         _tileGrid[x, y] = tile;
     }
     #endregion
@@ -100,5 +101,5 @@ public class WorldGrid : Node2D
 
     public ShaderMaterial GetTileMaterial(int idx) => _tileViews[idx].material;
 
-    public void _on_Clock_OnTick(int ticks) => _heat.Process();
+    public void _on_Clock_OnTick(int ticks) => _environment.Process();
 }

half-earth/scripts/tile/IDamageable.cs

@@ -1,4 +1,5 @@
 public interface IDamageable
 {
+    float HealRate { get; }
     float Threshold { get; }
 }

half-earth/scripts/tile/TileGrid.cs

@@ -89,5 +89,64 @@ public class TileGrid : Resource, IReadOnlyList<Tile>
     {
         return x >= 0 && x < Size && y >= 0 && y < Size;
     }
+
+    private readonly int[] _neighbours = new int[]
+    {
+        -1, 0,
+        0, 1,
+        1, 0,
+        0, -1
+    };
+
+    private void GetCoordinate(int dir, out int x, out int y)
+    {
+        dir %= 4;
+        int idx = dir * 2;
+        x = _neighbours[idx];
+        y = _neighbours[idx + 1];
+    }
+
+    public float GetNeighbourProportion<T>(int x, int y)
+    {
+        int typed = GetNeighbourCount<T>(x, y);
+        int all = GetNeighbourCount(x, y);
+        return (float)typed / (float)all;
+    }
+
+    public int GetNeighbourCount<T>(int x, int y)
+    {
+        int count = 0;
+        for (int i = 0; i < 4; i++)
+        {
+            GetCoordinate(i, out var nx, out var ny);
+
+            if (!IsInBounds(x + nx, y + ny))
+                continue;
+
+            if (!(this[x + nx, y + ny].type is T))
+                continue;
+
+            count++;
+        }
+
+        return count;
+    }
+
+    public int GetNeighbourCount(int x, int y)
+    {
+        int count = 0;
+
+        for (int i = 0; i < 4; i++)
+        {
+            GetCoordinate(i, out var nx, out var ny);
+
+            if (!IsInBounds(x + nx, y + ny))
+                continue;
+
+            count++;
+        }
+
+        return count;
+    }
 }
 

half-earth/scripts/tile/TileType.cs

@@ -17,4 +17,6 @@ public class TileType : Resource
     public float HeatGeneration { get; private set; }
 
     public override string ToString() => Name;
+
+    public virtual Tile ApplySpawneffect(Tile tile) => tile;
 }

half-earth/scripts/tile/Wild.cs

@@ -2,6 +2,15 @@ using Godot;
 
 public class Wild : TileType, IDamageable
 {
+    [Export]
+    public float HealRate { get; private set; } = 0.01f;
+
     [Export]
     public float Threshold { get; private set; }
+
+    public override Tile ApplySpawneffect(Tile tile)
+    {
+        tile.currentHealth = 0;
+        return tile;
+    }
 }

half-earth/scripts/ui/BuildModeUI.cs

@@ -20,10 +20,14 @@ public class BuildModeUI : Control
         _buildMode = GetNode<BuildMode>(_buildModePath);
 
         var buttonHeight = 40;
-        var tileType = _buildMode.BuildableTiles[0];
-        int x = 50;
 
-        SpawnButton(tileType, buttonHeight, ref x);
+        int x = 50;
+        int margin = 5;
+        foreach (var tt in _buildMode.BuildableTiles)
+        {
+            SpawnButton(tt, buttonHeight, ref x);
+            x += margin;
+        }
     }
 
     private void UpdateButtonToggleState(TileType tileType)