Limit how much random walkers fill of a certain grid

walkers_limit_fill_percent.gd

extends Node2D

onready var dirt_tilemap = $DirtTileMap
onready var wall_tilemap = $WallTileMap

var rng = RandomNumberGenerator.new()

var CellSize = Vector2(16, 16)
var width = 1024/CellSize.x
var height = 608/CellSize.y
var grid = []
var walkers = []

class Walker:
    var dir: Vector2
    var pos: Vector2

var max_iterations = 1000

var walker_max_count = 3
var walker_spawn_chance = 0.25
var walker_direction_chance = 0.5
var fill_percent = 0.5

var Tiles = {
    "empty": -1,
    "wall": 0,
    "floor": 1
}

func _init_walkers():
    walkers = []

    var walker = Walker.new()
    walker.dir = GetRandomDirection()
    walker.pos = Vector2.ZERO
    walkers.append(walker)

func _init_grid():
    grid = []
    for x in width:
        grid.append([])
        for y in height:
            grid[x].append(-1);
    

func GetRandomDirection():
    var directions = [[-1, 0], [1, 0], [0, 1], [0, -1]]
    var direction = directions[rng.randi()%4]
    return Vector2(direction[0], direction[1])
    
func _create_random_path():

    var itr = 0
    var n_tiles = 0
    
    while itr < max_iterations:
        
        # Perform random walk
        # 1- choose random direction, with chance
        # 2- spawn new walker, with chance
        # 3- check that direction is in bounds
        # 4- move in that direction
        
        # Change direction, with chance
        for i in range(walkers.size()):
            if rng.randf() < walker_direction_chance:
                walkers[i].dir = GetRandomDirection()
        
        # Spawn new walkers, with chance
        for i in range(walkers.size()):
            if rng.randf() < walker_spawn_chance and walkers.size() < walker_max_count:
                var walker = Walker.new()
                walker.dir = GetRandomDirection()
                walker.pos = walkers[i].pos
                walkers.append(walker)
    
        # Advance walkers
        for i in range(walkers.size()):
            
            if (walkers[i].pos.x + walkers[i].dir.x >= 0 and 
                walkers[i].pos.x + walkers[i].dir.x < width and
                walkers[i].pos.y + walkers[i].dir.y >= 0 and
                walkers[i].pos.y + walkers[i].dir.y < height):
                    
                    walkers[i].pos += walkers[i].dir
                    if grid[walkers[i].pos.x][walkers[i].pos.y] == Tiles.empty:
                        grid[walkers[i].pos.x][walkers[i].pos.y] = Tiles.floor
                        n_tiles += 1
                        
                        if float(n_tiles)/float(width*height) >= fill_percent:
                            return
        itr += 1


func _spawn_tiles():
    
    for x in width:
        for y in height:
            match grid[x][y]:
                Tiles.empty:
                    pass
                Tiles.floor:
                    dirt_tilemap.set_cellv(Vector2(x, y), 0)
                Tiles.wall:
                    pass
                    
    dirt_tilemap.update_bitmask_region()
    wall_tilemap.update_bitmask_region()

func _clear_tilemaps():
    for x in width:
        for y in height:
            dirt_tilemap.clear()
            wall_tilemap.clear()

func _ready():
    rng.randomize()
    _init_walkers()
    _init_grid()
    _clear_tilemaps()
    _create_random_path()
    _spawn_tiles()
    
func _input(event):
    if Input.is_key_pressed(KEY_SPACE):
        _init_walkers()
        _init_grid()
        _clear_tilemaps()
        _create_random_path()
        _spawn_tiles()