Zerge Boss support

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

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,6 +111,8 @@ 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

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

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 += "u"
-        #         fen += "*"
+        #     # for y in unit_string.length() - 1:
-        #     fen += "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",
+        "game_type": game_type,
-        "win_condition": Utils.WinConditionType.CAPTURE_UNIT,
+        "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

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
 

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
     

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:

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,

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*************")

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.")