docs/battlefield__generator_8gd_source.html

extends RefCounted


func generate(prototype:Dictionary, options := {}) -> Dictionary:

    var rng = RandomNumberGenerator.new()

    var seed = int(options.get("seed", Time.get_ticks_msec()))

    rng.seed = seed

    var mode = str(options.get("mode", "arena"))

    if mode == "battle":

        return _generate_battle(prototype, options, rng, seed)

    return _generate_arena(prototype, options, rng, seed)


func _generate_arena(prototype:Dictionary, options:Dictionary, rng:RandomNumberGenerator, seed:int) -> Dictionary:

    var world = prototype.get("world", {}).duplicate(true)

    var grid_size = _cell_from_value(world.get("grid_size", [12, 12]))

    var player_cell = _cell_from_value(prototype.get("player", {}).get("grid", [2, 2]))

    var exit_cell = _cell_from_value(prototype.get("exit", {}).get("cell", [grid_size.x - 1, grid_size.y - 1]))

    var blocked := {player_cell: true, exit_cell: true}

    for direction in [Vector2i.LEFT, Vector2i.RIGHT, Vector2i.UP, Vector2i.DOWN]:

        var safe_cell = player_cell + direction

        if safe_cell.x >= 0 and safe_cell.y >= 0 and safe_cell.x < grid_size.x and safe_cell.y < grid_size.y:

            blocked[safe_cell] = true

    var arena_options = prototype.get("arena", {})

    world["obstacles"] = _generate_obstacles(rng, grid_size, blocked, int(options.get("obstacles", arena_options.get("obstacles", 5))))

    var obstacle_cells := {}

    for obstacle in world.get("obstacles", []):

        for cell in obstacle.get("cells", []):

            obstacle_cells[_cell_from_value(cell)] = true

    for cell in obstacle_cells.keys():

        blocked[cell] = true

    world["material_nodes"] = _place_materials(rng, world.get("material_nodes", []), grid_size, blocked)

    for node in world.get("material_nodes", []):

        blocked[_cell_from_value(node.get("cell", [0, 0]))] = true

    world["spell_interactions"] = _place_interactions(rng, world.get("spell_interactions", []), grid_size, blocked)

    for interaction in world.get("spell_interactions", []):

        blocked[_cell_from_value(interaction.get("cell", [0, 0]))] = true

    var enemy_pool = _arena_enemy_pool(prototype.get("enemies", []), arena_options)

    var enemy_min = max(0, int(arena_options.get("enemy_count_min", min(1, enemy_pool.size()))))

    var enemy_max = max(enemy_min, int(arena_options.get("enemy_count_max", enemy_pool.size())))

    _shuffle_values(enemy_pool, rng)

    var enemy_count = min(enemy_pool.size(), rng.randi_range(enemy_min, enemy_max) if enemy_max > 0 else 0)

    var enemies = _place_enemies(rng, enemy_pool.slice(0, enemy_count), grid_size, blocked)

    return {

        "mode": "arena",

        "seed": seed,

        "world": world,

        "enemies": enemies,

        "player_grid": [player_cell.x, player_cell.y]

    }


func _generate_battle(prototype:Dictionary, options:Dictionary, rng:RandomNumberGenerator, seed:int) -> Dictionary:

    var half_size = clamp(int(options.get("half_size", 3)), 3, 5)

    var grid_size = Vector2i(half_size * 2, half_size)

    var tile_size = float(prototype.get("world", {}).get("tile_size", 40.0))

    var player_cell = Vector2i(max(0, int(half_size / 2)), max(0, int(half_size / 2)))

    var exit_cell = Vector2i(0, max(0, half_size - 1))

    var world = prototype.get("world", {}).duplicate(true)

    world["grid_size"] = [grid_size.x, grid_size.y]

    world["tile_size"] = tile_size

    world["obstacles"] = []

    world["material_nodes"] = []

    world["spell_interactions"] = []

    world["regions"] = [

        {"id": "player_side", "name": "Player Half", "cells": [0, 0, half_size, half_size], "color": "#172834"},

        {"id": "enemy_side", "name": "Enemy Half", "cells": [half_size, 0, half_size, half_size], "color": "#301820"}

    ]

    world["camera"] = {"viewport_tiles": [grid_size.x, max(5, grid_size.y)]}

    var blocked := {player_cell: true, exit_cell: true}

    var enemy_cells := []

    for y in range(grid_size.y):

        for x in range(half_size, grid_size.x):

            enemy_cells.append(Vector2i(x, y))

    _shuffle_cells(enemy_cells, rng)

    var enemies := []

    var enemy_pool = prototype.get("enemies", []).duplicate(true)

    _shuffle_values(enemy_pool, rng)

    var enemy_count = min(enemy_pool.size(), rng.randi_range(1, half_size))

    for index in range(enemy_count):

        var enemy = enemy_pool[index]

        if not enemy is Dictionary or enemy_cells.is_empty():

            continue

        var cell = enemy_cells.pop_back()

        if blocked.has(cell):

            continue

        blocked[cell] = true

        var entry = enemy.duplicate(true)

        entry["cell"] = [cell.x, cell.y]

        enemies.append(entry)

    return {

        "mode": "battle",

        "half_size": half_size,

        "seed": seed,

        "world": world,

        "enemies": enemies,

        "player_grid": [player_cell.x, player_cell.y],

        "exit": {

            "cell": [exit_cell.x, exit_cell.y],

            "active_after_enemies_defeated": true,

            "label": "Exit"

        }

    }


func _generate_obstacles(rng:RandomNumberGenerator, grid_size:Vector2i, blocked:Dictionary, count:int) -> Array:

    var obstacles := []

    var attempts := 0

    while obstacles.size() < count and attempts < count * 30:

        attempts += 1

        var cell = Vector2i(rng.randi_range(1, max(1, grid_size.x - 2)), rng.randi_range(1, max(1, grid_size.y - 2)))

        if blocked.has(cell):

            continue

        blocked[cell] = true

        obstacles.append({

            "id": "generated_obstacle_%d" % obstacles.size(),

            "name": "Field Obstacle",

            "cells": [[cell.x, cell.y]]

        })

    return obstacles


func _place_materials(rng:RandomNumberGenerator, nodes:Array, grid_size:Vector2i, blocked:Dictionary) -> Array:

    var placed := []

    for node in nodes:

        if not node is Dictionary:

            continue

        var cell = _random_open_cell(rng, grid_size, blocked)

        if cell == Vector2i(-1, -1):

            continue

        blocked[cell] = true

        var entry = node.duplicate(true)

        entry["cell"] = [cell.x, cell.y]

        placed.append(entry)

    return placed


func _place_interactions(rng:RandomNumberGenerator, interactions:Array, grid_size:Vector2i, blocked:Dictionary) -> Array:

    var placed := []

    for interaction in interactions:

        if not interaction is Dictionary:

            continue

        var cell = _random_open_cell(rng, grid_size, blocked)

        if cell == Vector2i(-1, -1):

            continue

        blocked[cell] = true

        var entry = interaction.duplicate(true)

        entry["cell"] = [cell.x, cell.y]

        placed.append(entry)

    return placed


func _place_enemies(rng:RandomNumberGenerator, enemies:Array, grid_size:Vector2i, blocked:Dictionary) -> Array:

    var placed := []

    for enemy in enemies:

        if not enemy is Dictionary:

            continue

        var cell = _random_open_cell(rng, grid_size, blocked)

        if cell == Vector2i(-1, -1):

            continue

        blocked[cell] = true

        var entry = enemy.duplicate(true)

        entry["cell"] = [cell.x, cell.y]

        placed.append(entry)

    return placed


func _arena_enemy_pool(enemies:Array, arena_options:Dictionary) -> Array:

    var allowed = arena_options.get("enemy_archetypes", [])

    var pool := []

    for enemy in enemies:

        if not enemy is Dictionary:

            continue

        if allowed is Array and not allowed.is_empty() and not allowed.has(str(enemy.get("archetype", ""))):

            continue

        pool.append(enemy.duplicate(true))

    return pool


func _random_open_cell(rng:RandomNumberGenerator, grid_size:Vector2i, blocked:Dictionary) -> Vector2i:

    for _attempt in range(200):

        var cell = Vector2i(rng.randi_range(0, grid_size.x - 1), rng.randi_range(0, grid_size.y - 1))

        if not blocked.has(cell):

            return cell

    return Vector2i(-1, -1)


func _shuffle_cells(cells:Array, rng:RandomNumberGenerator) -> void:

    for index in range(cells.size() - 1, 0, -1):

        var swap_index = rng.randi_range(0, index)

        var temp = cells[index]

        cells[index] = cells[swap_index]

        cells[swap_index] = temp


func _shuffle_values(values:Array, rng:RandomNumberGenerator) -> void:

    for index in range(values.size() - 1, 0, -1):

        var swap_index = rng.randi_range(0, index)

        var temp = values[index]

        values[index] = values[swap_index]

        values[swap_index] = temp


func _cell_from_value(value) -> Vector2i:

    if value is Vector2i:

        return value

    if value is Vector2:

        return Vector2i(int(value.x), int(value.y))

    if value is Array and value.size() >= 2:

        return Vector2i(int(value[0]), int(value[1]))

    return Vector2i.ZERO