half-earth/half-earth/scripts/WorldGrid.cs

using Godot;
using System;

public class WorldGrid : Node2D
{
    [Export]
    private PackedScene TileScene { get; set; }

    [Export]
    private Resource _tileGridResource;
    private TileGrid _tileGrid;

    [Export]
    public int CellSize { get; set; }

    [Export]
    public float DiffusionCoefficient { get; set; } = 0.01f;

    private float[] _nextValues = null;

    public struct TileView
    {
        public ShaderMaterial material;
    }
    private TileView[] _tileViews;

    // Called when the node enters the scene tree for the first time.
    public override void _Ready()
    {
        _tileGrid = (TileGrid)_tileGridResource;

        GenerateCanvasItems(_tileGrid);
    }

    #region Positioning
    public void GetGridPos(Vector2 position, out int x, out int y)
    {
        x = Mathf.FloorToInt(position.x / CellSize);
        y = Mathf.FloorToInt(position.y / CellSize);
    }

    public bool IsInBounds(int x, int y) => _tileGrid.IsInBounds(x, y);
    #endregion

    #region Interaction
    public void SetTileType(int x, int y, TileType tileType)
    {
        if (!_tileGrid.IsInBounds(x, y))
            return;

        _tileGrid.MapPosition(x, y, out var idx);

        var tile = _tileGrid[idx];
        tile.type = tileType;
        _tileGrid[x, y] = tile;

        _tileViews[idx].material.SetShaderParam("lowColor", tileType.Color);
    }
    #endregion

    private void Clear()
    {
        int children = this.GetChildCount();
        GD.Print(children);
        for (int i = 0; i < children; i++)
        {
            var child = this.GetChild(i);
            child.QueueFree();
        }

        _tileViews = null;
    }

    private void GenerateCanvasItems(TileGrid grid)
    {
        this.Clear();

        _tileViews = new TileView[grid.Count];
        _nextValues = new float[grid.Count];

        for (int i = 0; i < grid.Count; i++)
        {
            _tileGrid.MapIndex(i, out var x, out var y);

            var node = TileScene.Instance<Node2D>();
            this.AddChild(node);
            var position = new Vector2
            {
                x = (x + .5f) * CellSize,
                y = (y + .5f) * CellSize
            };
            node.Position = position;
            var canvasItem = (CanvasItem)node;

            var tile = _tileGrid[i];

            TileView view = default;
            view.material = (ShaderMaterial)canvasItem.Material;
            //view.material.SetShaderParam("lowColor", _tileGrid.StartTileType.Color);
            _tileViews[i] = view;
        }
    }

    public ShaderMaterial GetTileMaterial(int idx) => _tileViews[idx].material;

    #region Simulation
    public void _on_Clock_OnTick(int ticks)
    {
        GenerateHeat();
        Diffuse();
    }

    private float TransferHeat(float t0, float alpha, float nx, float ny, float px, float py)
    {
        float d2tdx2 = nx - 2 * t0 + px;
        float d2tdy2 = ny - 2 * t0 + py;
        return t0 + alpha * (d2tdx2 + d2tdy2);
    }

    private void GetNeighbourTemperatures(int x, int y, out float nx, out float ny, out float px, out float py)
    {
        // default value
        var t = _tileGrid[x, y].temperature;

        nx = x > 0 ? _tileGrid[x - 1, y].temperature : t;
        px = x < _tileGrid.Size - 1 ? _tileGrid[x + 1, y].temperature : t;

        ny = y > 0 ? _tileGrid[x, y - 1].temperature : t;
        py = y < _tileGrid.Size - 1 ? _tileGrid[x, y + 1].temperature : t;
    }

    private void ApplyHeatDamage(ref Tile tile)
    {
        if (!(tile.type is IDamageable damageable))
            return;

        var surplus = tile.temperature - damageable.Threshold;
        if (surplus < 0)
            return;

        // TODO: parameterised balancing
        tile.currentHealth -= surplus;
        tile.currentHealth = Mathf.Clamp(tile.currentHealth, 0, 1);
    }

    private void GenerateHeat()
    {
        for (int i = 0; i < _tileGrid.Count; i++)
        {
            var tile = _tileGrid[i];
            var type = tile.type;
            tile.temperature += type.HeatGeneration;
            ApplyHeatDamage(ref tile);
            _tileGrid[i] = tile;
        }
    }

    private void Diffuse()
    {
        var D = DiffusionCoefficient;

        for (int i = 0; i < _tileGrid.Count; i++)
        {
            float t = _tileGrid[i].temperature;

            _tileGrid.MapIndex(i, out var x, out var y);

            GetNeighbourTemperatures(
                x, y,
                out var nx,
                out var ny,
                out var px,
                out var py);

            var temperature = TransferHeat(t, D, nx, ny, px, py);

            // TODO: what if it's really really cold out?
            temperature = Mathf.Max(0, temperature);
            _nextValues[i] = temperature;
        }

        for (int i = 0; i < _tileGrid.Count; i++)
        {
            var tile = _tileGrid[i];
            tile.temperature = _nextValues[i];
            _tileGrid[i] = tile;
        }
    }
    #endregion
}