Water tiles don't spread evenly in 2D cellular automata

Question

I'm making a simple water simulation based on a cellular automata, but the water tiles don't spread evenly, what's the problem?

Here is my code:

private const string TITLE = "Water Simulation";

private const int MAP_WIDTH = 80;
private const int MAP_HEIGHT = 20;
private static int[,] map = new int[MAP_HEIGHT, MAP_WIDTH];

private static char cBound = '▓';
private static char cWater = '░';
private static char cSpace = ' ';

static void Main(string[] args)
{
    //WATER SIMULATION\\
    Console.CursorVisible = false;

    Random rnd = new Random();
    int counter = 500;

    while (true)
    {
        //Source of the water
        bool willCreateWaterTile = rnd.Next(0, 101) >= 50 && map[0, MAP_WIDTH / 2] == 0;
        if (willCreateWaterTile && counter > 0)
        {
            map[0, MAP_WIDTH / 2] = 1;
        }


      
        for (int y = MAP_HEIGHT - 1; y >= 0; --y)
        {
            for (int x = 0; x < MAP_WIDTH; ++x)
            {
                if (map[y, x] == 1)
                {
                    bool isFirstCheckLeft = rnd.Next(0, 101) >= 50;

                    if (InBounds(x, y + 1) && map[y + 1, x] == 0)
                    {
                        map[y + 1, x] = 1;
                        map[y, x] = 0;
                    }
                    else if (isFirstCheckLeft)
                    {
                        if (InBounds(x - 1, y) && map[y, x - 1] == 0)
                        {
                            map[y, x - 1] = 1;
                            map[y, x] = 0;
                        }
                        else if (InBounds(x + 1, y) && map[y, x + 1] == 0)
                        {
                            map[y, x + 1] = 1;
                            map[y, x] = 0;
                        }
                    }
                    else
                    {
                        if (InBounds(x + 1, y) && map[y, x + 1] == 0)
                        {
                            map[y, x + 1] = 1;
                            map[y, x] = 0;
                        }
                        else if (InBounds(x - 1, y) && map[y, x - 1] == 0)
                        {
                            map[y, x - 1] = 1;
                            map[y, x] = 0;
                        }                                
                    }
                    //____________________________//
                }
            }
        }


        Display();

        counter--;
    }
}

static bool InBounds(int x, int y)
{
    return x >= 0 && y >= 0 && y < MAP_HEIGHT && x < MAP_WIDTH;
}

I've looked at several guides. The code for me and the guides is almost identical, but even theirs distributes water evenly, but mine doesn’t.

Answer 1

The code for me and the guides is almost identical, but even theirs distributes water evenly, but mine doesn’t.

Then make it exactly identical. If it still doesn't work, the guide is bad and you should find a better one. If it does, something in what you changed is the cause.

---

Anyway, one obvious cause of left–right asymmetry that I can see is that you always iterate over the cells in each row from left to right.

That's going to bias the movement of blobs of water cells towards the left side, since a horizontal line of consecutive water cells can all move to the left together (each one moving into the space just vacated by the previous cell on the last iteration of the inner loop), whereas only the single rightmost cell in such a line can move to the right (and it only has a 50% chance of doing so).

I don't know what the guide you're following is doing to avoid that bias, but presumably they're either iterating over the cells in a different (perhaps randomly chosen) order, or they use two maps and write to one while reading from the other (which is the usual way cellular automata simulators prevent the behavior of the automaton from being affected by the order in which the cells are updated).