battle_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
var active := false
var player_card := {}
var opponent_card := {}
var player_hp := 0
var opponent_hp := 0
var player_turn := true
var reward := 0
var log := []
var last_event := {}
 
 
 
func battle(player_card:Dictionary, opponent_card:Dictionary, reward:int = 100) -> Dictionary:
    if player_card.is_empty() or opponent_card.is_empty():
        return {"winner": "none", "log": ["No battle could be started."], "reward": 0}
 
    var player = player_card.duplicate(true)
    var opponent = opponent_card.duplicate(true)
    var player_hp = int(player.get("health", 1))
    var opponent_hp = int(opponent.get("health", 1))
    var player_turn = randi_range(0, 1) == 0
    var log = [
        "%s faces %s." % [player.get("name", "Player"), opponent.get("name", "Opponent")]
    ]
 
    while player_hp > 0 and opponent_hp > 0:
        if player_turn:
            var damage = _roll_damage(player, opponent)
            opponent_hp -= damage
            log.append("%s hits for %d." % [player.get("name", "Player"), damage])
        else:
            var damage = _roll_damage(opponent, player)
            player_hp -= damage
            log.append("%s hits for %d." % [opponent.get("name", "Opponent"), damage])
        player_turn = not player_turn
 
    var player_won = player_hp > 0
    log.append("%s wins." % [player.get("name", "Player") if player_won else opponent.get("name", "Opponent")])
    return {
        "winner": "player" if player_won else "opponent",
        "reward": reward if player_won else 0,
        "log": log
    }
 
 
func _roll_damage(attacker:Dictionary, defender:Dictionary) -> int:
    return max(1, int(attacker.get("attack", 1)) + randi_range(1, 6) - int(defender.get("defense", 0)))
 
 
 
func start_battle(selected_player_card:Dictionary, selected_opponent_card:Dictionary, battle_reward:int = 100, starting_opponent_hp:int = -1) -> Dictionary:
    player_card = selected_player_card.duplicate(true)
    opponent_card = selected_opponent_card.duplicate(true)
    player_hp = int(player_card.get("health", 1))
    opponent_hp = starting_opponent_hp if starting_opponent_hp > 0 else int(opponent_card.get("health", 1))
    player_turn = randi_range(0, 1) == 0
    reward = battle_reward
    active = not player_card.is_empty() and not opponent_card.is_empty()
    log = []
    last_event = {}
    if active:
        log.append("%s faces %s." % [player_card.get("name", "Player"), opponent_card.get("name", "Opponent")])
        log.append("%s has initiative." % [player_card.get("name", "Player") if player_turn else opponent_card.get("name", "Opponent")])
    else:
        log.append("No battle could be started.")
    return get_state()
 
 
 
func clear_opponent() -> void:
    active = false
    player_card = {}
    opponent_card = {}
    player_hp = 0
    opponent_hp = 0
    log = []
    last_event = {}
 
 
 
func take_turn() -> Dictionary:
    if not active:
        last_event = {}
        return get_state()
 
    if player_turn:
        var player_roll = randi_range(1, 6)
        var player_damage = _calculate_damage(player_card, opponent_card, player_roll)
        opponent_hp -= player_damage
        log.append("%s rolls %d and deals %d damage." % [player_card.get("name", "Player"), player_roll, player_damage])
        last_event = _make_turn_event("player", "opponent", player_card, opponent_card, player_roll, player_damage, max(0, opponent_hp))
    else:
        var opponent_roll = randi_range(1, 6)
        var opponent_damage = _calculate_damage(opponent_card, player_card, opponent_roll)
        player_hp -= opponent_damage
        log.append("%s rolls %d and deals %d damage." % [opponent_card.get("name", "Opponent"), opponent_roll, opponent_damage])
        last_event = _make_turn_event("opponent", "player", opponent_card, player_card, opponent_roll, opponent_damage, max(0, player_hp))
 
    if player_hp <= 0 or opponent_hp <= 0:
        active = false
        last_event["defeated"] = true
        last_event["winner"] = get_winner()
        log.append("%s wins." % [player_card.get("name", "Player") if player_hp > 0 else opponent_card.get("name", "Opponent")])
    else:
        player_turn = not player_turn
 
    return get_state()
 
 
 
func get_state() -> Dictionary:
    return {
        "active": active,
        "player_card": player_card,
        "opponent_card": opponent_card,
        "player_hp": max(0, player_hp),
        "opponent_hp": max(0, opponent_hp),
        "player_turn": player_turn,
        "winner": get_winner(),
        "reward": reward if get_winner() == "player" else 0,
        "log": log.duplicate(),
        "last_event": last_event.duplicate(true)
    }
 
 
 
func get_winner() -> String:
    if active:
        return ""
    if player_card.is_empty() or opponent_card.is_empty():
        return "none"
    return "player" if player_hp > 0 else "opponent"
 
 
func _calculate_damage(attacker:Dictionary, defender:Dictionary, roll:int) -> int:
    return max(1, int(attacker.get("attack", 1)) + roll - int(defender.get("defense", 0)))
 
 
func _make_turn_event(attacker_side:String, defender_side:String, attacker:Dictionary, defender:Dictionary, roll:int, damage:int, defender_hp:int) -> Dictionary:
    return {
        "type": "damage",
        "attacker": attacker_side,
        "defender": defender_side,
        "attacker_id": str(attacker.get("id", attacker.get("base_id", ""))),
        "defender_id": str(defender.get("id", defender.get("base_id", ""))),
        "attacker_name": str(attacker.get("name", "Attacker")),
        "defender_name": str(defender.get("name", "Defender")),
        "roll": roll,
        "damage": damage,
        "hp_after": defender_hp,
        "defeated": defender_hp <= 0
    }