particles/Main.cs

using System.Collections.Generic;
using System.Linq;
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(200);
        _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, 0.35));
    }

    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 viewportRect = GetViewportRect();
        foreach (var p1 in _particles)
        {
            foreach (var p2 in _particles)
            {
                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)
                {
                    const float collisionStretch = 1f;
                    const float collisionOffset = 13f;
                    const float collisionFlatten = 1f;
                    var rawCollisionForce = -Mathf.Pow(Mathf.E, -(collisionStretch * distance - collisionOffset)) /
                                            collisionFlatten;
                    var clampedCollisionForce = Mathf.Clamp(rawCollisionForce, -1f, 1f);
                    p1.Velocity += direction * clampedCollisionForce;
                }
                // particle relationship force

                var props = p1.Type.GetRelationship(p2.Type);
                if (props.Force != 0f && distance >= props.MinRadius && distance <= props.MaxRadius)
                {
                    var slope = props.Force / ((props.MaxRadius - props.MinRadius) / 2f);
                    var rawParticleForce = -slope * Mathf.Abs(distance - (props.MinRadius + props.MaxRadius) / 2f) +
                                           props.Force;
                    p1.Velocity += direction * rawParticleForce;
                }

                p1.Velocity = p1.Velocity.Clamped(3f);
            }

            var position = p1.Position;
            position += p1.Velocity;
            p1.Velocity *= 0.95f;
            position.x = Mathf.Clamp(position.x, ParticleScreenPadding, viewportRect.Size.x - ParticleScreenPadding);
            position.y = Mathf.Clamp(position.y, ParticleScreenPadding, viewportRect.Size.y - ParticleScreenPadding);
            p1.Position = position;
        }
    }
}