Generate the same maze with a seed

Question

Im followed a tutorial to create a maze with Recursive Backtracking and it works great.

Im trying to create a game where people get on the same maze, and if someone wins, it creates a new maze and everyones current maze gets updated.

So what i was thinking is to have a seed to create the same maze and pass that seed to all the players so they can have the same maze.

Is there a way to modify it so i can give the maze a seed and it creates always the same maze?

This is what i have now:

It uses a Cell class (posx,posy)

class Cell(var col:Int = 0, var row: Int = 0){
    var topWall = true
    var leftWall = true
    var bottomWall = true
    var rightWall = true
    var visited = false
}
    fun createMaze(){
    var stack = Stack<Cell>()
    var current:Cell
    var next:Cell?


    for(x in 0 until COLS){
        for(y in 0 until ROWS){

            cells[x][y] = Cell(x,y)
        }
    }

    player = cells[0][0]
    exit = cells [COLS-1][ROWS-1]


    current = cells[0][0]
    current.visited = true

    do{
        next = getNeighbour(current)
        if(next != null) {
            removeWall(current, next)
            stack.push(current)
            current = next
            current.visited = true
        }else{
            current = stack.pop()
        }
    }while (!stack.empty())

}
fun getNeighbour(cell:Cell): Cell? {
    var vecinos: ArrayList<Cell> = ArrayList()
    //vecino izquierda
    if(cell.col > 0) {
        if (!cells[cell.col - 1][cell.row].visited) {
            vecinos.add(cells[cell.col - 1][cell.row])
        }
    }
    //vecino derecha
    if(cell.col < COLS - 1) {
        if (!cells[cell.col + 1][cell.row].visited) {
            vecinos.add(cells[cell.col + 1][cell.row])
        }
    }
    //vecino arriba
    if(cell.row > 0) {
        if (!cells[cell.col][cell.row - 1].visited) {
            vecinos.add(cells[cell.col ][cell.row - 1])
        }
    }
    //vecino abajo
    if(cell.row < ROWS - 1) {
        if (!cells[cell.col][cell.row + 1].visited) {
            vecinos.add(cells[cell.col][cell.row + 1])
        }
    }
    if (vecinos.size > 0) {
        var index = random.nextInt(vecinos.size)
        return vecinos[index]
    }else {
        return null
    }
}

fun removeWall(current:Cell,next:Cell){
    if (current.col == next.col && current.row == next.row +1){
        current.topWall = false
        next.bottomWall = false
    }
    if (current.col == next.col && current.row == next.row -1){
        current.bottomWall = false
        next.topWall = false
    }
    if (current.col == next.col + 1 && current.row == next.row){
        current.leftWall = false
        next.rightWall = false
    }
    if (current.col == next.col - 1 && current.row == next.row){
        current.rightWall = false
        next.leftWall = false
    }
}

Answer 1

If you want to pass a seed to create the maze, then you have to make sure that all of the players are using the same random number generator. Which means you have to supply your own random number generator implementation.

The application would seed the random number generator with the value you pass, and then it should deterministically generate the same sequence of random numbers for each client.

Note also that you can't ever change the random number generator implementation unless you can prove that the new implementation will generate exactly the same sequence of numbers that the original did.