particles/Main.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Godot;

public class Main : Node2D
{
    private const int ParticleScreenPadding = 16;

    private readonly List<ParticleType> _particleTypes = new List<ParticleType>();
    private List<Particle> _particles;

    private const int MaxParticles = 700;

    private const float HealthDelta = 0.002f;
    private const float PositiveHealthMultiplier = 2f;

    public override void _Ready()
    {
        GD.Randomize();
        InitializeParticleTypes(12);
        InitializeParticles(MaxParticles);
        
    }

    public override void _Process(float delta)
    {
        if (Input.IsActionJustPressed("quit")) GetTree().Quit();
        if (Input.IsActionJustPressed("reset")) GetTree().ReloadCurrentScene();
    }

    public override void _PhysicsProcess(float delta)
    {
        UpdateParticles();
    }

    private void InitializeParticleTypes(int nTypes)
    {
        for (var i = 0; i < nTypes; i++)
        {
            var type = new ParticleType
            {
                Hue = (float) GD.RandRange(0, 1)
            };
            _particleTypes.Add(type);
        }

        foreach (var type1 in _particleTypes)
            foreach (var type2 in _particleTypes)
                type1.AddRelationship(type2, 
                    new ParticleRelationshipProps(20, (float) GD.RandRange(25, 60), 
                        (float) GD.RandRange(-0.33 * 2f, 0.35 * 2f)));
    }

    private void InitializeParticles(int nParticles)
    {
        var typeCount = 0;
        var particleScene = GD.Load<PackedScene>("res://Particle.tscn");
        for (var i = 0; i < nParticles; i++)
        {
            var particle = particleScene.Instance<Particle>();
            GetNode<Node2D>("Particles").AddChild(particle);
            particle.Position = GetRandomParticlePosition();
            particle.Type = _particleTypes[typeCount];
            particle.Health = 1f;

            if (typeCount < _particleTypes.Count - 1)
                typeCount++;
            else
                typeCount = 0;
        }
    }

    private void CreateParticle(ParticleType type)
    {
        var particleScene = GD.Load<PackedScene>("res://Particle.tscn");
        var particle = particleScene.Instance<Particle>();
        GetNode<Node2D>("Particles").AddChild(particle);
        particle.Position = GetRandomParticlePosition();
        particle.Type = type;
        particle.Health = 1f;
    }

    private void CreateRandomParticle()
    {
        var randomIndex = (int)(GD.Randi() % _particleTypes.Count);
        var type = _particleTypes[randomIndex];
        CreateParticle(type);
    }
    
    private Vector2 GetRandomParticlePosition()
    {
        var viewportRect = GetViewportRect();
        var position = new Vector2(
            (float) GD.RandRange(ParticleScreenPadding, viewportRect.Size.x - ParticleScreenPadding),
            (float) GD.RandRange(ParticleScreenPadding, viewportRect.Size.y - ParticleScreenPadding));
        return position;
    }

    private void UpdateParticles()
    {
        _particles = GetNode<Node2D>("Particles").GetChildren().Cast<Particle>().ToList();
        var tasks = new Task[_particles.Count];
        var viewportRect = GetViewportRect();
        for (var i = 0; i < _particles.Count; i++) tasks[i] = Task.Factory.StartNew(UpdateParticle, _particles[i]);

        Task.WaitAll(tasks);

        var deletedParticle = false;

        foreach (var p in _particles)
        {
            if (deletedParticle == false && p.Health == 0f)
            {
                if (GD.Randf() < 0.2f)
                {
                    p.Free();
                    deletedParticle = true;
                    continue;
                }
            }
            var position = p.Position;
            p.Velocity = p.Velocity.Clamped(3f * 4f);
            position += p.Velocity;
            p.Velocity *= 0.875f;    // friction
            position.x = Mathf.Clamp(position.x, ParticleScreenPadding, viewportRect.Size.x - ParticleScreenPadding);
            position.y = Mathf.Clamp(position.y, ParticleScreenPadding, viewportRect.Size.y - ParticleScreenPadding);
            p.AddAverageSpeedValue(p.Position.DistanceTo(position));
            
            if (p.AverageSpeed < 0.3f)
                p.Health -= HealthDelta * 1.5f;
            else
                p.Health += HealthDelta;
            
            if (deletedParticle == false && p.Health == 0f)
            {
                if (GD.Randf() < 0.2f)
                {
                    p.Free();
                    deletedParticle = true;
                    continue;
                }
            }
            p.Position = position;
        }

        if (_particles.Count < MaxParticles)
            if (GD.Randf() < 0.3f)
                CreateRandomParticle();
    }

    private void UpdateParticle(object particle)
    {
        var p1 = (Particle) particle;
        var closeCount = 0;
        foreach (var p2 in _particles)
        {
            var viewportRect = GetViewportRect();
            if (p1 == p2)
                continue;
            var distance = p1.Position.DistanceTo(p2.Position);
            if (distance > 60f)
                continue;
            var direction = p1.Position.DirectionTo(p2.Position);


            if (distance < 70)
            {
                closeCount++;
            }
            
            // collision force
            if (distance < 20)
            {
                var collisionForce = 1f / (0.6f + Mathf.Pow(Mathf.E, -(distance - 12f))) - 1f / 0.6f;
                p1.Velocity += direction * collisionForce;
            }
            // particle relationship force

            var props = p1.Type.GetRelationship(p2.Type);
            if (props.Force == 0f || !(distance >= props.MinRadius) || !(distance <= props.MaxRadius))
                continue;
            var slope = props.Force / ((props.MaxRadius - props.MinRadius) / 2f);
            var particleForce = -slope * Mathf.Abs(distance - (props.MinRadius + props.MaxRadius) / 2f) +
                                props.Force;
            p1.Velocity += direction * particleForce;
        }
        
        if (closeCount < 3 || closeCount > 35)
            p1.Health -= HealthDelta * 1.5f;
        else
            p1.Health += HealthDelta;
        
    }
}