From 21688aa11bdb86aeaa2ac379f73886a9d8419335 Mon Sep 17 00:00:00 2001 From: 2ManyProjects Date: Sun, 9 Mar 2025 17:13:04 -0500 Subject: [PATCH] Zerge Boss support --- .../ChessEngines/fairy-chess-server/engine.js | 4 +- Systems/Cards/Explosiveboots.gd | 6 ++- Systems/Game/ChessGame.gd | 8 +++- Systems/Game/Map/MapGenerator.gd | 46 ++++++++++++++----- Systems/Game/WinConditionManager.gd | 5 +- Systems/StateMachine/GameStates/BlackTurn.gd | 1 - .../StateMachine/GameStates/CleanupPhase.gd | 1 + .../GameStates/EvaluatePosition.gd | 2 +- Systems/StateMachine/GameStates/Movement.gd | 6 ++- Systems/StateMachine/StateMachine.gd | 16 ++++++- 10 files changed, 72 insertions(+), 23 deletions(-) diff --git a/Assets/ChessEngines/fairy-chess-server/engine.js b/Assets/ChessEngines/fairy-chess-server/engine.js index fbf73a4..69f7413 100644 --- a/Assets/ChessEngines/fairy-chess-server/engine.js +++ b/Assets/ChessEngines/fairy-chess-server/engine.js @@ -28,7 +28,9 @@ class ChessEngine extends EventEmitter { this.engine.on('close', (code) => { console.log('Engine process closed with code:', code); - this.isReady = false; + // this.isReady = false; + //Certainly this cant go horrifically wrong + start() }); // Initialize engine diff --git a/Systems/Cards/Explosiveboots.gd b/Systems/Cards/Explosiveboots.gd index f741fa5..af10ebe 100644 --- a/Systems/Cards/Explosiveboots.gd +++ b/Systems/Cards/Explosiveboots.gd @@ -17,7 +17,7 @@ func reset(): valid = false func apply_effect(target_piece = null, board_flow = null, game_state = null): - print("EXPLOSIVE apply_effect", ) + print("EXPLOSIVE apply_effect", target_piece) attached_piece = target_piece stored_board_flow = board_flow stored_game_state = game_state @@ -111,7 +111,9 @@ func setup_persistent_effect(game_state): func on_turn_changed(): print("TURN CHANGED ==================", stored_game_state.isPlayerTurn() ) - + if stored_game_state.stateMachine.disabled: + return + if stored_game_state.isPlayerTurn() and attached_piece and remaining_turns > 0: var piece = attached_piece var flow = stored_board_flow diff --git a/Systems/Game/ChessGame.gd b/Systems/Game/ChessGame.gd index 54bc0dc..ca3b93c 100644 --- a/Systems/Game/ChessGame.gd +++ b/Systems/Game/ChessGame.gd @@ -103,10 +103,12 @@ func _ready() -> void: turnIndicator.visible = false deckManager = DeckManager.new() # 2rnbqkbnr1R/2ppp1pppp2/5p6/75/66/66/66/66/66/66/2PPPPPPPP2/2RNBQKBN3 b KQkq - 0 3 +# clear prev wind conditions? func _on_new_game_requested(options = {}): print("ChessGame received new_game_requested signal ", is_initialized) captured_pieces_this_turn = [] player_pieces_lost_this_turn = [] + moveCount = 1 turnIndicator.visible = true has_opponent = true if cameraController: @@ -137,6 +139,7 @@ func _on_new_game_requested(options = {}): if cardDisplay: cardDisplay.visible = true if stateMachine: + stateMachine.enable() stateMachine.transitionToNextState(Constants.WHITE_TURN) else: initialize_game_system() @@ -796,13 +799,16 @@ func check_captured_pieces_conditions(): if winConditionManager: winConditionManager.on_piece_captured(piece) print(captured_pieces_this_turn) + captured_pieces_this_turn = [] # Process captured player pieces (possible loss condition) for piece in player_pieces_lost_this_turn: if winConditionManager: winConditionManager.on_piece_lost(piece) print(player_pieces_lost_this_turn) + player_pieces_lost_this_turn = [] func _on_win_condition_met(condition_data): + stateMachine.disable() print("Win condition met: ", condition_data) recover_cards_from_player_pieces() emit_signal("node_completed", { @@ -817,6 +823,7 @@ func _on_win_condition_met(condition_data): # endRound() func _on_loss_condition_met(condition_data): + stateMachine.disable() print("Loss condition met: ", condition_data) recover_cards_from_player_pieces() emit_signal("node_completed", { @@ -988,7 +995,6 @@ func getPieceFenChar(piece: Pawn) -> String: "Queen": fenChar = "q" "King": fenChar = "k" - # In our system, Item_Color == 1 is white, 0 is black return fenChar.to_upper() if piece.Item_Color == 0 else fenChar # Unused diff --git a/Systems/Game/Map/MapGenerator.gd b/Systems/Game/Map/MapGenerator.gd index 104df09..17878e5 100644 --- a/Systems/Game/Map/MapGenerator.gd +++ b/Systems/Game/Map/MapGenerator.gd @@ -265,41 +265,62 @@ func generate_boss_data(node): # level_unit_distribution # current_max_level var rng = float(node.level) / int(current_max_level) + var game_type = "zerg" + var height = 6; # (current_value, min_value, max_value, min_index, max_index) var index = map_to_array_index(node.level, 2, current_max_level - 2, 1, level_unit_distribution.size() - 1); + if game_type == "zerg": + index = 7 + height = 7 + # if game_type == "zerg": + # index = map_to_array_index(node.level, 5, current_max_level - 2, 1, level_unit_distribution.size() - 1); var unit_string = level_unit_distribution[index] var pawn_string = "" + var enemy_unit_depth = 3 for x in unit_string.length(): pawn_string += "p" - var height = 6; -# "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR" + var fen = ""; - if node.level > 7 and node.level <= 10: +# "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR" + if node.level >= 7 and node.level <= 10: height = node.level + enemy_unit_depth = 3 elif node.level > 10: height = 10 - for x in height - 2: + enemy_unit_depth = 4 + for x in height - enemy_unit_depth: if x == 0: fen += unit_string + "/" elif x == 1: fen += pawn_string + "/" # elif x == height - 3: - # for y in unit_string.length() - 1: - # fen += "*" - # fen += "1/" + # fen += "u" + # # for y in unit_string.length() - 1: + # # fen += "*" + # fen += "u/" else: fen += str(unit_string.length()) + "/" - fen += pawn_string.to_upper() + "/" + unit_string.to_upper() + + if game_type == "zerg": + for x in enemy_unit_depth - 1: + fen += pawn_string.to_upper() + "/" + fen += pawn_string.to_upper() + else: + fen += pawn_string.to_upper() + "/" + unit_string.to_upper() var fen_ending = " w KQkq - 0 1" # print("generate_chess_data ", fen + fen_ending) return { "is_escape": node.metadata.is_escape if node.metadata.has("is_escape") else false, "fen": fen + fen_ending, - "game_type": "chess", - "win_condition": Utils.WinConditionType.CAPTURE_UNIT, + "game_type": game_type, + "win_condition": Utils.WinConditionType.TURN_NUMBER, + "win_target_turn": 30, + "has_opponent": true, + "loss_target_unit": "King", + "loss_condition": Utils.LossConditionType.UNIT_LOST, "reward": { "gold": 50 * node.level, "cards": [], @@ -351,7 +372,7 @@ func generate_event_data(node): elif node.level > 10: height = 10 # var mazedata = generate_maze(width, height) - var mazedata = generate_maze(16, 16) + var mazedata = generate_maze(12, 12) # print("**************************") # print("**************************") # print("**************************") @@ -391,7 +412,7 @@ func generate_chess_data(node): var height = 6; # "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR" var fen = ""; - if node.level > 7 and node.level <= 10: + if node.level > 8 and node.level <= 10: height = node.level elif node.level > 10: height = 10 @@ -477,6 +498,7 @@ func generate_chess_data(node): "game_type": "chess", "win_condition": win_condition, "loss_condition": loss_condition, + "has_opponent": true, "elo": node.elo, "reward": { "gold": 50 * node.level diff --git a/Systems/Game/WinConditionManager.gd b/Systems/Game/WinConditionManager.gd index 2afbe3d..1e6247b 100644 --- a/Systems/Game/WinConditionManager.gd +++ b/Systems/Game/WinConditionManager.gd @@ -221,6 +221,7 @@ func count_enemy_pieces() -> int: # Helper methods for game integration func load_condition_from_metadata(metadata: Dictionary): + reset_conditions(); # print("load_condition_from_metadata ", metadata) if metadata.has("win_condition"): match metadata["win_condition"]: @@ -235,14 +236,14 @@ func load_condition_from_metadata(metadata: Dictionary): Utils.WinConditionType.BOARD_CLEARED: set_win_condition(Utils.WinConditionType.BOARD_CLEARED) Utils.WinConditionType.TURN_NUMBER: - set_win_condition(Utils.WinConditionType.TURN_NUMBER, {"target_turn": metadata.get("target_turn", 20)}) + set_win_condition(Utils.WinConditionType.TURN_NUMBER, {"target_turn": metadata.get("win_target_turn", 20)}) if metadata.has("loss_condition"): match metadata["loss_condition"]: Utils.LossConditionType.UNIT_LOST: set_loss_condition(Utils.LossConditionType.UNIT_LOST, {"unit": "King"}) Utils.LossConditionType.TURN_NUMBER: - set_loss_condition(Utils.LossConditionType.TURN_NUMBER, {"turn_limit": metadata.get("turn_limit", 50)}) + set_loss_condition(Utils.LossConditionType.TURN_NUMBER, {"turn_limit": metadata.get("loss_turn_limit", 50)}) # Debug methods diff --git a/Systems/StateMachine/GameStates/BlackTurn.gd b/Systems/StateMachine/GameStates/BlackTurn.gd index a3dd54e..63365c0 100644 --- a/Systems/StateMachine/GameStates/BlackTurn.gd +++ b/Systems/StateMachine/GameStates/BlackTurn.gd @@ -15,7 +15,6 @@ func _ready() -> void: add_child(stateDelay) func enter(_previous: String, _data := {}) -> void: - game.moveCount += 1; print("ENTERING STATE ", Constants.BLACK_TURN) game.currentPlayer = game.BLACK diff --git a/Systems/StateMachine/GameStates/CleanupPhase.gd b/Systems/StateMachine/GameStates/CleanupPhase.gd index acd2ef1..8d960ba 100644 --- a/Systems/StateMachine/GameStates/CleanupPhase.gd +++ b/Systems/StateMachine/GameStates/CleanupPhase.gd @@ -3,6 +3,7 @@ extends "res://Systems/StateMachine/ChessGameState.gd" func enter(_previous: String, data := {}) -> void: print("ENTERING STATE ", Constants.CLEANUP, data) + game.moveCount += 1; if "endCondition" in data: finished.emit(Constants.ROUND_END) elif game.currentPlayer == game.WHITE and game.has_opponent: diff --git a/Systems/StateMachine/GameStates/EvaluatePosition.gd b/Systems/StateMachine/GameStates/EvaluatePosition.gd index 832cf53..e0b119e 100644 --- a/Systems/StateMachine/GameStates/EvaluatePosition.gd +++ b/Systems/StateMachine/GameStates/EvaluatePosition.gd @@ -48,8 +48,8 @@ func check_win_conditions() -> bool: return true Utils.WinConditionType.TURN_NUMBER: - print("check_win_conditions ", "Utils.WinConditionType.TURN_NUMBER") var target_turn = game.winConditionManager.win_condition_data.get("target_turn", 0) + print("check_win_conditions ", "Utils.WinConditionType.TURN_NUMBER ", target_turn , " ?= ", game.winConditionManager.turn_count ) if game.winConditionManager.turn_count >= target_turn: var condition_data = { "type": Utils.WinConditionType.TURN_NUMBER, diff --git a/Systems/StateMachine/GameStates/Movement.gd b/Systems/StateMachine/GameStates/Movement.gd index b51c2a3..ee1d5be 100644 --- a/Systems/StateMachine/GameStates/Movement.gd +++ b/Systems/StateMachine/GameStates/Movement.gd @@ -76,12 +76,14 @@ func handleMovement(location: String, generated: bool = false) -> void: # we need to prevent swapping of focus between peices after the double move process has started # maybe once u start nmoving a peice global stat var is set # and any moving peice needs ot match that - print("HANDLING MOVEMENT ", location, " | ", last_selected, " | ", game.selectedNode) var node = game.get_node("Flow/" + location) as PieceContainer + print("HANDLING MOVEMENT ", location, " | ", last_selected, " | ", game.selectedNode) + if node.has_piece(): + print(node.get_piece()) var prev_last_selected = last_selected if !generated : if last_selected == null: @@ -140,7 +142,7 @@ func handleMovement(location: String, generated: bool = false) -> void: game.getMovableAreas() return - if game.selectedNode == location and location == prev_last_selected: + if !generated and game.selectedNode == location and location == prev_last_selected: # print("CAN CLEAR SELECTION************* ", multiMoving, " !is_multi_moving ", !is_multi_moving) if !is_multi_moving and multiMoving == "": print("CLEAR SELECTION*************") diff --git a/Systems/StateMachine/StateMachine.gd b/Systems/StateMachine/StateMachine.gd index fb0d5f8..39a195f 100644 --- a/Systems/StateMachine/StateMachine.gd +++ b/Systems/StateMachine/StateMachine.gd @@ -8,6 +8,7 @@ class_name StateMachine extends Node @onready var parent = get_parent() var previouseState = null +var disabled = true @onready var stateString: RichTextLabel = owner.get_node("StateLabel") @@ -15,6 +16,7 @@ func _ready() -> void: print("Ready Statemachine") func start() -> void: + disabled = false for stateNode: ChessGameState in find_children("*", "ChessGameState"): stateNode.game = owner stateNode.finished.connect(transitionToNextState) @@ -22,7 +24,12 @@ func start() -> void: await owner.ready state.enter("") func enter() -> void: + disabled = false state.enter("") +func enable() -> void: + disabled = false +func disable() -> void: + disabled = true func unhandledInput(event: InputEvent) -> void: # print("StateMachine received input:", event) @@ -33,8 +40,15 @@ func process(delta: float) -> void: state.update(delta) - func transitionToNextState(targetStatePath: String, data: Dictionary = {}) -> void: + if disabled: + previouseState = state.name + state.exit() + state = get_node(Constants.ROUND_END) + stateString.text = Constants.ROUND_END; + state.enter(previouseState, data) + print("DISABLED TRANSITION TO: ", targetStatePath, "Going to", Constants.ROUND_END) + return print("TRANSITIONING TO: ", targetStatePath) if not has_node(targetStatePath): printerr(owner.name + ": Trying to transition to state " + targetStatePath + " but it does not exist.")