Add PlayerRole class and formation file readers to handle player roles

naderzare · naderzare · commit 5f52c305beed · 2024-12-01T05:23:31.000-04:00
diff --git a/src/strategy/formation_file.py b/src/strategy/formation_file.py
@@ -1,128 +1,9 @@
 from scipy.spatial import Delaunay
 from pyrusgeom.geom_2d import *
-from enum import Enum
 from pyrusgeom.soccer_math import min_max
 import logging
-from abc import ABC, abstractmethod
-import json
-
-
-class FormationType(Enum):
-    Static = 's'
-    DelaunayTriangulation2 = 'D'
-
-class FormationIndexData:
-    def __init__(self, ball, players):
-        self._ball: list[float] = ball
-        self._players: list[list[float]] = players
-        
-    def ball(self) -> list[float]:
-        return self._ball
-    
-    def players(self) -> list[list[float]]:
-        return self._players
-
-class PlayerRole:
-    def __init__(self, name, type, side, pair):
-        self._name = name
-        self._type = type
-        self._side = side
-        self._pair = pair
-        
-class IFormationFileReader(ABC):
-    @abstractmethod
-    def read_file(self, path) -> list[FormationIndexData]:
-        pass
-    
-class OldStaticFormationFileReader(IFormationFileReader):
-    def read_file(self, lines):
-        players = {}
-        roles = {}
-        for i in range(len(lines)):
-            if i == 0 or lines[i].startswith('#'):
-                continue
-            player = lines[i].split()
-            players[int(player[0])] = ([float(player[2]), float(player[3])])
-            roles[int(player[0])] = PlayerRole(player[1], None, None, None)
-        
-        return [FormationIndexData(None, players)], roles
-
-class OldDelaunayFormationFileReader(IFormationFileReader):
-    def read_file(self, lines):
-        roles = {}
-        begin_roles = False
-        for i in range(len(lines)):
-            if lines[i].startswith('Begin Roles'):
-                begin_roles = True
-                continue
-            if lines[i].startswith('End Roles'):
-                break
-            if begin_roles:
-                player = lines[i].split()
-                roles[int(player[0])] = PlayerRole(player[1], None, None, int(player[2]))
-        indexes = []
-        for i in range(len(lines)):
-            if lines[i].find('Ball') >= 0:
-                indexes.append(self.read_index(i, lines))
-            i += 11
-        return indexes, roles
-
-    def read_index(self, i, lines):
-        ball = lines[i].split(' ')
-        ball_x = float(ball[1])
-        ball_y = float(ball[2])
-        ball = [ball_x, ball_y]
-        players = {}
-        for j in range(1, 12):
-            player = lines[i + j].split(' ')
-            player_x = float(player[1])
-            player_y = float(player[2])
-            players[j] = ([player_x, player_y])
-        return FormationIndexData(ball, players)
-    
-class JsonFormationFileReader(IFormationFileReader):
-    def read_file(self, lines) -> list[FormationIndexData]:
-        text = ''.join(lines)
-        data = json.loads(text)
-        roles = {}
-        for role in data['role']:
-            roles[role['number']] = PlayerRole(role['name'], role['type'], role['side'], role['pair'])
-        indexes = []
-        for index in data['data']:
-            ball = [index['ball']['x'], index['ball']['y']]
-            players = {}
-            for i in range(1, 12):
-                players[i] = [index[str(i)]['x'], index[str(i)]['y']]
-            indexes.append(FormationIndexData(ball, players))
-        return indexes, roles
-    
-    @staticmethod
-    def is_json(lines):
-        return lines[0].find('{') >= 0
-    
-    @staticmethod
-    def get_method(lines):
-        text = ''.join(lines)
-        data = json.loads(text)
-        if data['method'] == 'Static':
-            return FormationType.Static
-        return FormationType.DelaunayTriangulation2
-        
-        
-class FormationFileReaderFactory:
-    def get_reader(self, lines) -> list[IFormationFileReader, FormationType]:
-        if JsonFormationFileReader.is_json(lines):
-            return JsonFormationFileReader(), JsonFormationFileReader.get_method(lines)
-        if lines[0].find('Static') >= 0:
-            return OldStaticFormationFileReader(), FormationType.Static
-        return OldDelaunayFormationFileReader(), FormationType.DelaunayTriangulation2
-    
-    def read_file(self, path) -> list[FormationIndexData]:
-        file = open(path, 'r')
-        lines = file.readlines()
-        reader, formation_type = self.get_reader(lines)
-        indexes, roles = reader.read_file(lines)
-        return indexes, roles, formation_type
+from src.strategy.formation_file_reader import FormationFileReaderFactory, FormationType
+from src.strategy.player_role import PlayerRole
 
 class FormationFile:
     def __init__(self, path, logger: logging.Logger):
@@ -133,11 +14,12 @@ def __init__(self, path, logger: logging.Logger):
         self._formation_type = FormationType.Static
         self._target_players = {}
         self._path = path
+        self._roles: dict[int, PlayerRole] = {}
         self.read_file(path)
         self.calculate()
 
     def read_file(self, path):
-        indexes, roles, self._formation_type = FormationFileReaderFactory().read_file(path)
+        indexes, self._roles, self._formation_type = FormationFileReaderFactory().read_file(path)
         
         if self._formation_type == FormationType.Static:
             data = indexes[0]
@@ -202,6 +84,9 @@ def get_pos(self, unum):
 
     def get_poses(self):
         return self._target_players
+    
+    def get_role(self, unum) -> PlayerRole:
+        return self._roles[unum]
 
     def __repr__(self):
         return self._path
diff --git a/src/strategy/formation_file_reader.py b/src/strategy/formation_file_reader.py
@@ -0,0 +1,116 @@
+from pyrusgeom.geom_2d import *
+from enum import Enum
+from abc import ABC, abstractmethod
+import json
+from src.strategy.player_role import PlayerRole
+        
+        
+class FormationType(Enum):
+    Static = 's'
+    DelaunayTriangulation2 = 'D'
+
+class FormationIndexData:
+    def __init__(self, ball, players):
+        self._ball: list[float] = ball
+        self._players: list[list[float]] = players
+        
+    def ball(self) -> list[float]:
+        return self._ball
+    
+    def players(self) -> list[list[float]]:
+        return self._players
+
+class IFormationFileReader(ABC):
+    @abstractmethod
+    def read_file(self, path) -> list[list[FormationIndexData], dict[int, PlayerRole]]:
+        pass
+    
+class OldStaticFormationFileReader(IFormationFileReader):
+    def read_file(self, lines: list[str]) -> list[list[FormationIndexData], dict[int, PlayerRole]]:
+        players = {}
+        roles = {}
+        for i in range(len(lines)):
+            if i == 0 or lines[i].startswith('#'):
+                continue
+            player = lines[i].split()
+            players[int(player[0])] = ([float(player[2]), float(player[3])])
+            roles[int(player[0])] = PlayerRole(player[1], None, None, None)
+        
+        return [FormationIndexData(None, players)], roles
+
+class OldDelaunayFormationFileReader(IFormationFileReader):
+    def read_file(self, lines: list[str]) -> list[list[FormationIndexData], dict[int, PlayerRole]]:
+        roles = {}
+        begin_roles = False
+        for i in range(len(lines)):
+            if lines[i].startswith('Begin Roles'):
+                begin_roles = True
+                continue
+            if lines[i].startswith('End Roles'):
+                break
+            if begin_roles:
+                player = lines[i].split()
+                roles[int(player[0])] = PlayerRole(player[1], None, None, int(player[2]))
+        indexes = []
+        for i in range(len(lines)):
+            if lines[i].find('Ball') >= 0:
+                indexes.append(self.read_index(i, lines))
+            i += 11
+        return indexes, roles
+
+    def read_index(self, i: int, lines: list[str]) -> FormationIndexData:
+        ball = lines[i].split(' ')
+        ball_x = float(ball[1])
+        ball_y = float(ball[2])
+        ball = [ball_x, ball_y]
+        players = {}
+        for j in range(1, 12):
+            player = lines[i + j].split(' ')
+            player_x = float(player[1])
+            player_y = float(player[2])
+            players[j] = ([player_x, player_y])
+        return FormationIndexData(ball, players)
+    
+class JsonFormationFileReader(IFormationFileReader):
+    def read_file(self, lines: list[str]) -> list[list[FormationIndexData], dict[int, PlayerRole]]:
+        text = ''.join(lines)
+        data = json.loads(text)
+        roles = {}
+        for role in data['role']:
+            roles[role['number']] = PlayerRole(role['name'], role['type'], role['side'], role['pair'])
+        indexes = []
+        for index in data['data']:
+            ball = [index['ball']['x'], index['ball']['y']]
+            players = {}
+            for i in range(1, 12):
+                players[i] = [index[str(i)]['x'], index[str(i)]['y']]
+            indexes.append(FormationIndexData(ball, players))
+        return indexes, roles
+    
+    @staticmethod
+    def is_json(lines: list[str]) -> bool:
+        return lines[0].find('{') >= 0
+    
+    @staticmethod
+    def get_method(lines: list[str]) -> FormationType:
+        text = ''.join(lines)
+        data = json.loads(text)
+        if data['method'] == 'Static':
+            return FormationType.Static
+        return FormationType.DelaunayTriangulation2
+        
+        
+class FormationFileReaderFactory:
+    def get_reader(self, lines) -> list[IFormationFileReader, FormationType]:
+        if JsonFormationFileReader.is_json(lines):
+            return JsonFormationFileReader(), JsonFormationFileReader.get_method(lines)
+        if lines[0].find('Static') >= 0:
+            return OldStaticFormationFileReader(), FormationType.Static
+        return OldDelaunayFormationFileReader(), FormationType.DelaunayTriangulation2
+    
+    def read_file(self, path) -> list[list[FormationIndexData], dict[int, PlayerRole], FormationType]:
+        file = open(path, 'r')
+        lines = file.readlines()
+        reader, formation_type = self.get_reader(lines)
+        indexes, roles = reader.read_file(lines)
+        return indexes, roles, formation_type
diff --git a/src/strategy/formation_strategy.py b/src/strategy/formation_strategy.py
@@ -1,12 +1,14 @@
 from src.interfaces.IPositionStrategy import IPositionStrategy
 from src.strategy.formation_file import *
 from src.interfaces.IAgent import IAgent
+from src.strategy.player_role import PlayerRole, RoleName, RoleType, RoleSide
 from enum import Enum
 from pyrusgeom.soccer_math import *
 from service_pb2 import *
 import logging
 
 
+
 class Situation(Enum):
     OurSetPlay_Situation = 0,
     OppSetPlay_Situation = 1,
@@ -112,9 +114,24 @@ def update(self, agent: IAgent):
                 
         logger.debug(f'{self._poses=}')
         
-    def get_position(self, uniform_number):
+    def get_position(self, uniform_number) -> Vector2D:
         return self._poses[uniform_number]
     
+    def get_role_name(self, uniform_number) -> int:
+        return self.current_formation_file.get_role(uniform_number).name
+    
+    def get_role_type(self, uniform_number) -> int:
+        return self.current_formation_file.get_role(uniform_number).type
+    
+    def get_role_side(self, uniform_number) -> int:
+        return self.current_formation_file.get_role(uniform_number).side
+    
+    def get_role_pair(self, uniform_number) -> int:
+        return self.current_formation_file.get_role(uniform_number).pair
+    
+    def get_role(self, uniform_number) -> PlayerRole:
+        return self.current_formation_file.get_role(uniform_number)
+    
     def get_offside_line(self):
         home_poses_x = [pos.x() for pos in self._poses.values()]
         home_poses_x.sort()
diff --git a/src/strategy/player_role.py b/src/strategy/player_role.py
@@ -0,0 +1,48 @@
+from enum import Enum
+
+
+class RoleName(Enum):
+    Goalie = "Goalie"
+    CenterBack = "CenterBack"
+    SideBack = "SideBack"
+    DefensiveHalf = "DefensiveHalf"
+    OffensiveHalf = "OffensiveHalf"
+    SideForward = "SideForward"
+    CenterForward = "CenterForward"
+    Unknown = "Unknown"
+    
+class RoleType(Enum):
+    G = "G"
+    DF = "DF"
+    MF = "MF"
+    FW = "FW"
+    Unknown = "Unknown"
+    
+class RoleSide(Enum):
+    L = "L"
+    R = "R"
+    C = "C"
+    Unknown = "Unknown"
+
+class PlayerRole:
+    def __init__(self, name: str, type: str, side: str, pair: int):
+        self._name: RoleName = RoleName(name) if name in RoleName.__members__ else RoleName.Unknown
+        self._type: RoleType = RoleType(type) if type in RoleType.__members__ else RoleType.Unknown
+        self._side: RoleSide = RoleSide(side) if side in RoleSide.__members__ else RoleSide.Unknown
+        self._pair: int = pair
+        
+    @property
+    def name(self) -> RoleName:
+        return self._name
+    
+    @property
+    def type(self) -> RoleType:
+        return self._type
+    
+    @property
+    def side(self) -> RoleSide:
+        return self._side
+    
+    @property
+    def pair(self) -> int:
+        return self._pair
