"Updated BhvStarterKickPlanner to import and use other behaviors, and modified KickDecisionMaker to use BhvStarterKickPlanner."

Author: ErfanFathii

src/behaviors/bhv_starter_clearball.py

@@ -0,0 +1,39 @@
+from src.interfaces.IBehavior import IBehavior
+from src.interfaces.IAgent import IAgent
+from pyrusgeom.soccer_math import *
+from pyrusgeom.geom_2d import *
+from src.utils.tools import Tools
+from pyrusgeom import vector_2d
+from service_pb2 import *
+
+class ClearBall(IBehavior):
+
+    def __init__(self):
+        pass
+    
+
+    def execute(self, agent: IAgent):
+        wm = agent.wm
+        ball_pos = Vector2D(wm.ball.position.x, wm.ball.position.y)
+        target = Vector2D(agent.server_params.pitch_half_length, 0.0)
+        if ball_pos.x() > -25.0 :
+            if ball_pos.dist(Vector2D(0.0, -agent.server_params.pitch_half_width)) < ball_pos.dist(Vector2D(0.0, agent.server_params.pitch_half_width)) :
+                target = Vector2D(0.0,-34.0)
+            else:
+                target = Vector2D(0.0,34.0)
+        else :
+            if abs(ball_pos.y()) < 10 and ball_pos.x() < -10.0 :
+                if ball_pos.y() > 0.0 :
+                    target = Vector2D(-agent.server_params.pitch_half_length, 20.0)
+                else :
+                    target = Vector2D(-agent.server_params.pitch_half_length, -20.0)
+            else:
+                if ball_pos.y() > 0.0 :
+                    target = Vector2D(ball_pos.x(), 34.0)
+                else : 
+                    target = Vector2D(ball_pos.x(), -34.0)
+        return PlayerAction(body_smart_kick=Body_SmartKick(target_point=RpcVector2D(x=target.x(), y=target.y()),
+                                                                        first_speed=2.7,
+                                                                            first_speed_threshold=2.7,
+                                                                                max_steps=2))
+        

src/behaviors/bhv_starter_dribble.py

@@ -0,0 +1,33 @@
+from src.interfaces.IBehavior import IBehavior
+from src.interfaces.IAgent import IAgent
+from src.utils.tools import Tools
+from pyrusgeom.vector_2d import Vector2D
+from pyrusgeom.sector_2d import Sector2D
+from service_pb2 import *
+
+
+class Dribble(IBehavior):
+
+    def __init__(self):
+        pass
+
+    def execute(self, agent: IAgent):
+        wm = agent.wm
+        ball_pos = Vector2D(wm.ball.position.x, wm.ball.position.y)
+        dribble_angle = (Vector2D(52.5, 0) - ball_pos).th().degree()
+        dribble_speed = 0.8
+        dribble_threshold = 0.7
+        dribble_sector = Sector2D(ball_pos, 0, 3, dribble_angle - 15, dribble_angle + 15)
+        
+        if not Tools.ExistOpponentIn(agent , dribble_sector):
+            Target = Vector2D.polar2vector(3, dribble_angle) + ball_pos
+            return PlayerAction(body_smart_kick=Body_SmartKick(target_point=RpcVector2D(x=Target.x(), y=Target.y()),
+                                                                first_speed=dribble_speed,
+                                                                    first_speed_threshold=dribble_threshold,
+                                                                        max_steps=2))
+        return
+
+
+    
+
+

src/behaviors/bhv_starter_kick_planner.py

@@ -3,14 +3,39 @@
 from pyrusgeom.soccer_math import *
 from pyrusgeom.geom_2d import *
 from service_pb2 import *
-
+from src.behaviors.bhv_starter_clearball import ClearBall
+from src.behaviors.bhv_starter_pass import Pass
+from src.behaviors.bhv_starter_dribble import Dribble
+from src.behaviors.bhv_starter_shoot import Shoot
+from src.utils.tools import Tools
 
 class BhvStarterKickPlanner(IBehavior):
     def __init__(self):
-        pass
+        self.shoot = Shoot()
+        self.clear_ball = ClearBall()
+        self.dribble = Dribble()
+        self.pass_ball = Pass()
 
     def execute(self, agent: IAgent):
         agent.logger.debug("BhvStarterKickPlanner.execute")
         from src.sample_player_agent import SamplePlayerAgent  # Local import to avoid circular import
-        assert isinstance(agent, SamplePlayerAgent)
-        raise NotImplementedError("BhvStarterKickPlanner.execute not implemented")
+        actions = []
+        actions += [shoot] if (shoot := self.shoot.execute(agent)) is not None else []
+        opps = Tools.OpponentsFromSelf(agent)
+        nearest_opp = opps[0] if opps else None
+        nearest_opp_dist = nearest_opp.dist_from_self if nearest_opp else 1000.0
+        
+        if nearest_opp_dist < 10:
+            actions += [passing] if (passing := self.pass_ball.execute(agent)) is not None else []
+            
+        actions += [dribble] if (dribble := self.dribble.execute(agent)) is not None else []
+        
+        if nearest_opp_dist > 2.5:
+            actions.append(PlayerAction(body_hold_ball=Body_HoldBall()))
+
+        actions.append(self.clear_ball.execute(agent))
+        
+        #Sending actions' queue
+        for i in actions:
+            if not i == []:
+                agent.add_action(i)

src/behaviors/bhv_starter_pass.py

@@ -0,0 +1,43 @@
+from src.interfaces.IBehavior import IBehavior
+from src.interfaces.IAgent import IAgent
+from pyrusgeom.soccer_math import *
+from pyrusgeom.geom_2d import *
+from src.utils.tools import Tools
+from service_pb2 import *
+
+
+class Pass(IBehavior):
+
+    def __init__(self):
+        pass
+
+    def execute(self, agent: IAgent) -> PlayerAction:
+        
+        wm = agent.wm
+        target = []
+        ball_pos = Vector2D(wm.ball.position.x, wm.ball.position.y)
+        self_pos = Vector2D(wm.self.position.x, wm.self.position.y)
+        for i in wm.teammates :
+            if i == None or i.uniform_number == wm.self.uniform_number or i.uniform_number < 0:
+                continue
+            tm_pos = Vector2D(i.position.x, i.position.y)
+            if tm_pos.dist(ball_pos) > 30.0 :
+                continue
+            if self_pos.dist(tm_pos) < 2.0:
+                continue
+            check_root = Sector2D(ball_pos, 1.0, tm_pos.dist(ball_pos) + 3.0, (tm_pos - ball_pos).th().degree() - 15.0, (tm_pos - ball_pos).th().degree() + 15.0)
+            if not Tools.ExistOpponentIn(agent, check_root):
+                target.append(i)
+                
+        if not target == []:
+            best_target = target[0]
+            for i in target:
+                if i.position.x > best_target.position.x:
+                    best_target = i
+            if not wm.game_mode_type == GameModeType.PlayOn:
+                return PlayerAction(body_smart_kick=Body_SmartKick(target_point=best_target.position, first_speed=2.7, first_speed_threshold=2.5, max_steps=1))
+            else :
+                return PlayerAction(body_smart_kick=Body_SmartKick(target_point=best_target.position, first_speed=2.5, first_speed_threshold=2.5, max_steps=1))
+        
+        return 
+                

src/behaviors/bhv_starter_shoot.py

@@ -0,0 +1,39 @@
+from src.interfaces.IBehavior import IBehavior
+from src.interfaces.IAgent import IAgent
+from pyrusgeom.vector_2d import Vector2D
+from service_pb2 import *
+
+
+
+class Shoot(IBehavior):
+    def __init__(self):
+        pass
+    
+    def execute(self, agent: IAgent):
+        wm = agent.wm
+        ball_pos = Vector2D(wm.ball.position.x, wm.ball.position.y)
+        ball_max_velocity = agent.server_params.ball_speed_max
+
+        center_goal = Vector2D ( agent.server_params.pitch_half_length, 0.0 )
+        right_goal = Vector2D ( agent.server_params.pitch_half_length , agent.server_params.goal_width / 2.0 ) # Lower Pole 
+        left_goal = Vector2D ( agent.server_params.pitch_half_length , -(agent.server_params.goal_width / 2.0) ) # Upper Pole 
+        
+        if ball_pos.dist(center_goal) <= 25.0:
+
+            if left_goal.dist(ball_pos) < right_goal.dist(ball_pos):
+                agent.add_log_message(LoggerLevel.SHOOT, f": Shooting to {left_goal}", agent.wm.self.position.x, agent.wm.self.position.y - 2, '\033[31m')
+                return PlayerAction(body_smart_kick=Body_SmartKick(target_point=RpcVector2D(x=left_goal.x(), y=left_goal.y()),
+                                                                                first_speed=ball_max_velocity ,
+                                                                                    first_speed_threshold=0.1 ,
+                                                                                        max_steps=2))
+            else :
+                agent.add_log_message(LoggerLevel.SHOOT, f": Shooting to {right_goal}", agent.wm.self.position.x, agent.wm.self.position.y - 2, '\033[31m')
+                return PlayerAction(body_smart_kick=Body_SmartKick(target_point=RpcVector2D(x=right_goal.x(), y=right_goal.y()),
+                                                                                first_speed=ball_max_velocity ,
+                                                                                    first_speed_threshold=0.1 ,
+                                                                                        max_steps=2))
+        return
+
+
+        
+

src/decision_makers/kick_decision_maker.py

@@ -10,10 +10,11 @@
 class KickDecisionMaker(IDecisionMaker):
     def __init__(self):
         self.bhv_kick_planner = BhvKickPlanner()
-        # self.bhv_kick_planner = BhvStarterKickPlanner()
+        self.bhv_kick_planner = BhvStarterKickPlanner()
 
     def make_decision(self, agent: IAgent):
         agent.logger.debug("--- WithBallDecisionMaker ---")
         from src.sample_player_agent import SamplePlayerAgent  # Local import to avoid circular import
         assert isinstance(agent, SamplePlayerAgent)
+        #self.bhv_kick_planner.execute(agent)
         self.bhv_kick_planner.execute(agent)