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;

    public override void _Ready()
    {
        GD.Randomize();
        InitializeParticleTypes(10);
        InitializeParticles(700);
        _particles = GetNode<Node2D>("Particles").GetChildren().Cast<Particle>().ToList();
    }

    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, 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];

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

    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()
    {
        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);

        foreach (var p in _particles)
        {
            var position = p.Position;
            p.Velocity = p.Velocity.Clamped(3f * 2f);
            position += p.Velocity;
            p.Velocity *= 0.85f;
            position.x = Mathf.Clamp(position.x, ParticleScreenPadding, viewportRect.Size.x - ParticleScreenPadding);
            position.y = Mathf.Clamp(position.y, ParticleScreenPadding, viewportRect.Size.y - ParticleScreenPadding);
            p.Position = position;
        }
    }

    private void UpdateParticle(object particle)
    {
        var p1 = (Particle) particle;
        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);

            // 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;
        }
    }
}