Update

Author: Ematerasu

AIService/Server.py

@@ -1,5 +1,4 @@
-from threading import Lock
-from typing import List
+from typing import Tuple
 import grpc
 from concurrent import futures
 
@@ -10,15 +9,17 @@
 from ScriptsOfTribute.enums import PatronId
 
 class AIService(main_pb2_grpc.AIServiceServicer):
-    def __init__(self, ai: BaseAI, server_instance):
+    def __init__(self, ai: BaseAI, server_instance, engine_service_port:int):
         self.ai = ai
         self.server_instance = server_instance
+        self.engine_service_port = engine_service_port
         self.engine_service_stub = None
 
-    def set_engine_service_stub(self, stub):
-        self.engine_service_stub = stub
-
     def RegisterBot(self, request, context):
+        engine_service_channel1 = grpc.insecure_channel(f"localhost:{self.engine_service_port}")
+        self.engine_service_stub = main_pb2_grpc.EngineServiceStub(engine_service_channel1)
+        print(f"Registering {self.ai.bot_name}")
+        print(f"localhost:{self.engine_service_port}")
         return main_pb2.RegistrationStatus(name=self.ai.bot_name, message="")
 
     def PregamePrepare(self, request, context):
@@ -32,10 +33,11 @@ def SelectPatron(self, request, context):
 
     def Play(self, request, context):
         game_state = build_game_state(request.gameState, self.engine_service_stub)
-        # game_state.debug_print()
+        #game_state.debug_print()
         moves = [from_proto_move(proto_move) for proto_move in request.possibleMoves]
-        move = self.ai.play(game_state, moves)
-        return move.to_proto()
+        move = self.ai.play(game_state, moves, request.remainingTimeMs).to_proto()
+        # print(move)
+        return move
 
     def GameEnd(self, request, context):
         self.ai.game_end(request)
@@ -53,36 +55,54 @@ class Server:
 
     def __init__(self):
         self.active_bots = 0
+        self.server = None
     def add_bot(self):
         self.active_bots += 1
-        print(f"Bot connected. Active bots: {self.active_bots}")
+        #print(f"Bot connected. Active bots: {self.active_bots}")
 
     def bot_disconnected(self):
         self.active_bots -= 1
-        print(f"Bot disconnected. Active bots: {self.active_bots}")
+        #print(f"Bot disconnected. Active bots: {self.active_bots}")
         if self.active_bots == 0:
             self.shutdown_server()
 
     def shutdown_server(self):
         if self.server:
-            print("No active bots. Shutting down the server...")
+            #print("No active bots. Shutting down the server...")
             self.server.stop(0)
         else:
             print("Server is already stopped.")
 
-    def run_grpc_server(self, ai_instances: List[BaseAI], port=50000, debug_prints=True):
-        self.server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
-        for i, ai in enumerate(ai_instances):
-            self.add_bot()
-            ai_service = AIService(ai, self)
-            assigned_port = port + i
-            self.server.add_insecure_port(f"localhost:{assigned_port}")
-            engine_service_channel = grpc.insecure_channel(f"localhost:{assigned_port}")
-            engine_service_stub = main_pb2_grpc.EngineServiceStub(engine_service_channel)
-            if debug_prints:
-                print(f"Bot {ai.bot_name} listening on localhost:{assigned_port}")
-            ai_service.set_engine_service_stub(engine_service_stub)
+def run_grpc_server(
+        bot1: BaseAI | None,
+        bot2: BaseAI | None,
+        base_client_ports: Tuple[int, int]=(50000, 50001),
+        base_server_ports: Tuple[int, int]=(49000, 49001),
+        debug_prints=True
+    ):
+    if bot1 is not None:
+        server1 = Server()
+        server1.server = grpc.server(futures.ThreadPoolExecutor(max_workers=5))
+        server1.add_bot()
+        ai_service1 = AIService(bot1, server1, base_server_ports[0])
+        server1.server.add_insecure_port(f"localhost:{base_client_ports[0]}")
+        main_pb2_grpc.add_AIServiceServicer_to_server(ai_service1, server1.server)
+        if debug_prints:
+            print(f"Bot {bot1.bot_name} listening on localhost:{base_client_ports[0]}, channel for engine service open on: {base_server_ports[0]}")
+        server1.server.start()
+
+    if bot2 is not None:
+        server2 = Server()
+        server2.server = grpc.server(futures.ThreadPoolExecutor(max_workers=5))
+        server2.add_bot()
+        ai_service2 = AIService(bot2, server2, base_server_ports[1])
+        server2.server.add_insecure_port(f"localhost:{base_client_ports[1]}")
+        main_pb2_grpc.add_AIServiceServicer_to_server(ai_service2, server2.server)
+        if debug_prints:
+            print(f"Bot {bot2.bot_name} listening on localhost:{base_client_ports[1]}, channel for engine service open on: {base_server_ports[1]}")
+        server2.server.start()
 
-            main_pb2_grpc.add_AIServiceServicer_to_server(ai_service, self.server)
-        self.server.start()
-        return self.server
+    if bot1 is not None:
+        server1.server.wait_for_termination()
+    if bot2 is not None:
+        server2.server.wait_for_termination()

AIService/base_ai.py

@@ -14,7 +14,7 @@ def pregame_prepare(self):
     def select_patron(self, available_patrons: List[PatronId]):
         raise NotImplementedError
 
-    def play(self, game_state: GameState, possible_moves: List[BasicMove]) -> BasicMove:
+    def play(self, game_state: GameState, possible_moves: List[BasicMove], remaining_time: int) -> BasicMove:
         raise NotImplementedError
 
     def game_end(self, final_state):

Bots/MaxPrestigeBot.py

@@ -1,24 +1,54 @@
 import random
 
 from AIService.base_ai import BaseAI
+from ScriptsOfTribute.enums import PlayerEnum, MoveEnum
+from ScriptsOfTribute.move import BasicMove
 
 class MaxPrestigeBot(BaseAI):
+
+    def __init__(self, bot_name):
+        super().__init__(bot_name)
+        self.player_id: PlayerEnum = PlayerEnum.NO_PLAYER_SELECTED
+        self.start_of_game: bool = True
 
     def select_patron(self, available_patrons):
-        #print(f"MaxPrestigeBot select patron: {available_patrons}")
-        return random.choice(available_patrons)
+        pick = random.choice(available_patrons)
+        return pick
 
-    def play(self, game_state, possible_moves):
+    def play(self, game_state, possible_moves, remaining_time):
         best_move = None
-        best_prestige = -1
+        best_move_val = -1
+        if self.start_of_game:
+            self.player_id = game_state.current_player.player_id
+            self.start_of_game = False
 
         for first_move in possible_moves:
             new_game_state, new_moves = game_state.apply_move(first_move)
 
+            if new_game_state.end_game_state is not None:  # check if game is over, if we win we are fine with this move
+                if new_game_state.end_game_state.winner == self.player_id:
+                    return first_move
+
+            if len(new_moves) == 1 and new_moves[0].command == MoveEnum.END_TURN:  # if there are no moves possible then lets just check value of this game state
+                curr_val = new_game_state.current_player.prestige + new_game_state.current_player.power
+                if curr_val > best_move_val:
+                    best_move = first_move
+                    best_move_val = curr_val
+
             for second_move in new_moves:
+                if second_move.command == MoveEnum.END_TURN:
+                    continue
                 final_game_state, _ = new_game_state.apply_move(second_move)
-
-        return random.choice(possible_moves)
+                if final_game_state.end_game_state is not None:
+                    if final_game_state.end_game_state.winner == self.player_id:
+                        return second_move
+                curr_val = final_game_state.current_player.prestige + final_game_state.current_player.power
+                if curr_val > best_move_val:
+                    best_move = first_move
+                    best_move_val = curr_val
+        if best_move is None:
+            return BasicMove(command=MoveEnum.END_TURN)
+        return best_move
 
     def game_end(self, final_state):
         pass

Bots/RandomBot.py

@@ -5,12 +5,13 @@
 class RandomBot(BaseAI):
 
     def select_patron(self, available_patrons):
-        print("RandomBot select patron")
+        #print("RandomBot select patron")
         return random.choice(available_patrons)
 
-    def play(self, game_state, possible_moves):
+    def play(self, game_state, possible_moves, remaining_time):
         # game_state.debug_print()
-        return random.choice(possible_moves)
+        pick = random.choice(possible_moves)
+        return pick
 
     def game_end(self, final_state):
         pass

Game/game.py

@@ -1,39 +1,105 @@
+import atexit
+import multiprocessing
+
+import os
+import signal
+import time
 from typing import List
 from AIService.base_ai import BaseAI
 from Game.runner import run_game_runner
-from AIService.Server import Server
+from AIService.Server import run_grpc_server
 
 class Game:
     def __init__(self):
         self.bots: List[BaseAI] = []
+        self.processes: List[multiprocessing.Process] = []
+
+        atexit.register(self._cleanup_processes)
 
     def register_bot(self, bot_instance: BaseAI):
+        # We register bots here, because some run invokes might involve C# native bots, so we always pass str there
         self.bots.append(bot_instance)
 
-    def run(self, bot1Name: str, bot2Name: str, start_game_runner=True, runs=1, threads=1, enable_logs="NONE", log_destination="", seed=None, timeout=30):
-        bots = filter(lambda bot: bot.bot_name == bot1Name or bot.bot_name == bot2Name, self.bots)
+    def run(
+        self,
+        bot1Name: str,
+        bot2Name: str,
+        start_game_runner=True,
+        runs=1,
+        threads=1,
+        enable_logs="NONE",
+        log_destination="",
+        seed=None,
+        timeout=30,
+        base_client_port=50000,
+        base_server_port=49000
+    ):
+        bot1 = next((bot for bot in self.bots if bot.bot_name == bot1Name), None)
+        bot2 = next((bot for bot in self.bots if bot.bot_name == bot2Name), None)
+        self.processes = []
+        if bot1 is not None or bot2 is not None:
+            self.processes.extend(self._run_bot_instances(bot1, bot2, threads, base_client_port, base_server_port))
         if start_game_runner:
+            time.sleep(2) # give servers some time to start
             if any([bot1Name == bot.bot_name for bot in self.bots]):
                 bot1Name = "grpc:" + bot1Name
             if any([bot2Name == bot.bot_name for bot in self.bots]):
                 bot2Name = "grpc:" + bot2Name
-            run_game_runner(
-                bot1Name,
-                bot2Name, 
-                runs=runs,
-                threads=threads,
-                enable_logs=enable_logs,
-                log_destination=log_destination,
-                seed=seed,
-                timeout=timeout
+            game_runner_process = multiprocessing.Process(
+                target=run_game_runner,
+                name='GameRunner',
+                args=(bot1Name, bot2Name, runs, threads, enable_logs, log_destination, seed, timeout),
+                daemon=True
             )
-
-    def _run_bot_instances(self, bots: List[BaseAI]):
-        server = Server()
-        grpc_server = server.run_grpc_server(bots)
-
+            game_runner_process.start()
+            self.processes.append(game_runner_process)
         try:
-            grpc_server.wait_for_termination()
+            for p in self.processes:
+                p.join()  # Wait for all processes to finish
+                print(f'Finished {p.name}')
         except KeyboardInterrupt:
-            grpc_server.close()
             print("Server interrupted by user.")
+            for p in self.processes:
+                p.terminate()  # Terminate all processes on interruption
+
+    def _run_bot_instances(
+        self,
+        bot1: BaseAI | None,
+        bot2: BaseAI | None,
+        num_threads: int,
+        base_client_port: int,
+        base_server_port: int,
+    ):
+        processes = []
+        for i in range(num_threads):
+            client_port1 = base_client_port + i
+            server_port1 = base_server_port + i
+            client_port2 = base_client_port + num_threads + i
+            server_port2 = base_server_port + num_threads + i
+
+            p = multiprocessing.Process(
+                target=run_grpc_server,
+                name=f"{bot1.bot_name if bot1 else 'C# bot'} - {bot2.bot_name if bot2 else 'C# bot'} on {(client_port1, client_port2)}, {(server_port1, server_port2)}",
+                args=(bot1, bot2, (client_port1, client_port2), (server_port1, server_port2)),
+                #daemon=True
+            )
+            p.start()
+            processes.append(p)
+
+        return processes
+
+
+    def _cleanup_processes(self):
+        print("Cleaning up all processes...")
+
+        for p in self.processes:
+            if p.is_alive():
+                print(f"Terminating {p.name} (PID {p.pid})")
+                p.terminate()
+                p.join(timeout=5)
+                
+                if p.is_alive():
+                    print(f"Forcing kill on {p.name} (PID {p.pid})")
+                    os.kill(p.pid, signal.SIGKILL)
+
+        self.processes.clear()

Game/runner.py

@@ -22,7 +22,7 @@ def run_game_runner(bot1: str, bot2: str, runs=1, threads=1, enable_logs="NONE",
     if seed:
         args += ["-s", str(seed)]
     args += ["-to", str(timeout)]
-    
+    print(f'Running: {args}')
     try:
         result = subprocess.run(
             args,

GameRunner/GameRunner.dll

@@ -0,0 +1,9 @@
+{
+    "Logging": {
+        "LogLevel": {
+        "Default": "Warning",
+        "Microsoft": "Warning",
+        "Microsoft.Hosting.Lifetime": "None"
+        }
+    }
+}