Change protos to cover engine service

Author: Ematerasu

.gitignore

@@ -0,0 +1,108 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+# IDE-specific files
+.vscode/
+.idea/

AIService/Server.py

@@ -0,0 +1,81 @@
+from threading import Lock
+from typing import Dict, List, Type
+import grpc
+from concurrent import futures
+from Protos import main_pb2_grpc, main_pb2
+from AIService.base_ai import BaseAI
+
+class AIService(main_pb2_grpc.AIServiceServicer):
+    def __init__(self, ai: BaseAI, server_instance):
+        self.ai = ai
+        self.server_instance = server_instance
+
+    def RegisterBot(self, request, context):
+        return main_pb2.RegistrationStatus(name=self.ai.bot_name, message="")
+
+    def PregamePrepare(self, request, context):
+        self.ai.pregame_prepare()
+        return main_pb2.Empty()
+
+    def SelectPatron(self, request, context):
+        patron = self.ai.select_patron(request.availablePatrons)
+        return main_pb2.PatronIdMessage(patronId=patron)
+
+    def Play(self, request, context):
+        import pdb; pdb.set_trace()
+        move = self.ai.play(request.gameState, request.possibleMoves)
+        return move
+
+    def GameEnd(self, request, context):
+        self.ai.game_end(request)
+        return main_pb2.Empty()
+    
+    def CloseServer(self, request, context):
+        print("Received CloseServer request. Shutting down server...")
+        self.server_instance.bot_disconnected()
+        context.set_code(grpc.StatusCode.OK)
+        context.set_details(f"Bot {self.ai.bot_name}'s connection closed.")
+        return main_pb2.Empty()
+    
+
+class Server:
+
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls, *args, **kwargs):
+        with cls._lock:
+            if not cls._instance:
+                cls._instance = super().__new__(cls)
+                cls._instance.active_bots = 0
+                cls._instance.server = None
+                cls._instance.lock = Lock()
+        return cls._instance
+
+    def add_bot(self):
+        with self.lock:
+            self.active_bots += 1
+            print(f"Bot connected. Active bots: {self.active_bots}")
+
+    def bot_disconnected(self):
+        with self.lock:
+            self.active_bots -= 1
+            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...")
+            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()
+            main_pb2_grpc.add_AIServiceServicer_to_server(AIService(ai, self), self.server)
+            self.server.add_insecure_port(f"[::]:{port+i}")
+        self.server.start()
+        return self.server

AIService/base_ai.py

@@ -0,0 +1,15 @@
+class BaseAI:
+    def __init__(self, bot_name):
+        self.bot_name = bot_name
+
+    def pregame_prepare(self):
+        pass
+
+    def select_patron(self, available_patrons):
+        raise NotImplementedError
+
+    def play(self, game_state, possible_moves):
+        raise NotImplementedError
+
+    def game_end(self, final_state):
+        pass

Game/game.py

@@ -0,0 +1,33 @@
+from typing import List
+from AIService.base_ai import BaseAI
+from Game.runner import run_game_runner
+from AIService.Server import Server
+
+class Game:
+    def __init__(self):
+        self.bots: List[BaseAI] = []
+
+    def register_bot(self, bot_instance: BaseAI):
+        self.bots.append(bot_instance)
+
+    def run(self, bot1Name: str, bot2Name: str, start_game_runner=True, runs=1, enable_logs="NONE", log_destination="", seed=None, timeout=30):
+        server = Server()
+        grpc_server = server.run_grpc_server(filter(lambda bot: bot.bot_name == bot1Name or bot.bot_name == bot2Name, self.bots))
+        if start_game_runner:
+            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, 
+                enable_logs=enable_logs,
+                log_destination=log_destination,
+                seed=seed,
+                timeout=timeout
+            )
+        try:
+            grpc_server.wait_for_termination()
+        except KeyboardInterrupt:
+            print("Server interrupted by user.")

Game/runner.py

@@ -0,0 +1,38 @@
+import os
+import subprocess
+
+def run_game_runner(bot1: str, bot2: str, runs=1, threads=1, enable_logs="NONE", log_destination="", seed=None, timeout=30):
+    game_runner_path = "GameRunner.exe"
+    game_runner_dir = os.path.join(os.getcwd(), "GameRunner")
+    
+    if not os.path.exists(game_runner_dir):
+        raise FileNotFoundError(f"Couldn't find directory {game_runner_dir}")
+    
+    os.chdir(game_runner_dir)
+    
+    if not os.path.exists(game_runner_path):
+        raise FileNotFoundError(f"Couldn't find file {game_runner_path}")
+    
+    args = [game_runner_path, bot1, bot2]
+    args += ["-n", str(runs)]
+    args += ["-t", str(threads)]
+    args += ["-l", enable_logs]
+    if log_destination:
+        args += ["-d", log_destination]
+    if seed:
+        args += ["-s", str(seed)]
+    args += ["-to", str(timeout)]
+    
+    try:
+        result = subprocess.run(
+            args,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        print(f"{result.stdout}")
+    except subprocess.CalledProcessError as e:
+        print(f"Error running GameRunner.exe:\n{e.stderr}")
+        raise RuntimeError(e)
+