def __init__(self): super().__init__(start_state=DoubleTouchTracker.State.start) for state in DoubleTouchTracker.State: self.add_state(state) # FIXME: is it only restart plays? self.add_transition( DoubleTouchTracker.State.start, DoubleTouchTracker.State.restart_play_began, lambda: (main.root_play().play is not None and main.root_play().play.__class__.is_restart() and main.game_state().is_our_restart()), 'we start running an offensive restart play') self.add_transition( DoubleTouchTracker.State.restart_play_began, DoubleTouchTracker.State.kicking, lambda: ((any(self._touching_ball(bot) for bot in main.our_robots())) or main.game_state().is_playing()) and not main.game_state().is_placement(), 'one of our bots has the ball or the ball was kicked') self.add_transition(DoubleTouchTracker.State.kicking, DoubleTouchTracker.State.kicker_forbidden, # The ball is no longer in restart, we have begun playing (lambda: main.game_state().is_playing() or # We aren't in a restart anymore main.root_play().play is None or not main.root_play().play.__class__.is_restart()), 'ball has moved and is now in play') self.add_transition(DoubleTouchTracker.State.kicker_forbidden, DoubleTouchTracker.State.other_robot_touched, lambda: self.other_robot_touching_ball(), 'another robot has touched the ball')
def __init__(self): super().__init__(continuous=False) for substate in Penalty.State: self.add_state(substate, behavior.Behavior.State.running) self.add_transition(behavior.Behavior.State.start, Penalty.State.waiting, lambda: True, 'immediately') self.add_transition(Penalty.State.waiting, Penalty.State.setup, lambda: main.game_state().is_setup_state(), 'ref says time to setup') for state in [Penalty.State.waiting, Penalty.State.setup]: self.add_transition(state, Penalty.State.ready, lambda: main.game_state().is_ready_state(), 'ref says ready') self.add_transition(Penalty.State.ready, behavior.Behavior.State.completed, lambda: self.subbehavior_with_name('kick').state == behavior.Behavior.State.completed, 'done kicking')
def __init__(self): super().__init__(continuous=True) for substate in Goalie.State: self.add_state(substate, behavior.Behavior.State.running) self.add_transition(behavior.Behavior.State.start, Goalie.State.chill, lambda: True, "immediately") self.add_transition(Goalie.State.chill, Goalie.State.defend, lambda: main.ball().valid, "ball is valid") non_chill_states = [s for s in Goalie.State if s != Goalie.State.chill] # if ball is invalid, chill for state in non_chill_states: self.add_transition(state, Goalie.State.chill, lambda: not main.ball().valid, "ball is invalid") for state in non_chill_states: self.add_transition( state, Goalie.State.setup_penalty, lambda: main.game_state().is_their_penalty() and main.game_state().is_setup_state(), "setting up for opponent penalty") for state in [s2 for s2 in non_chill_states if s2 != Goalie.State.intercept]: self.add_transition( state, Goalie.State.intercept, lambda: evaluation.ball.is_moving_towards_our_goal() and not self.robot_is_facing_our_goal(evaluation.ball.opponent_with_ball()), "ball coming towards our goal") for state in [s2 for s2 in non_chill_states if s2 != Goalie.State.clear]: self.add_transition( state, Goalie.State.clear, lambda: evaluation.ball.is_in_our_goalie_zone() and not main.game_state().is_their_penalty() and not evaluation.ball.is_moving_towards_our_goal() and evaluation.ball.opponent_with_ball() is None, "ball in our goalie box, but not headed toward goal") for state in [s2 for s2 in non_chill_states if s2 != Goalie.State.defend]: self.add_transition( state, Goalie.State.defend, lambda: not evaluation.ball.is_in_our_goalie_zone() and not evaluation.ball.is_moving_towards_our_goal() and not main.game_state().is_their_penalty() and not self.robot_is_facing_our_goal(evaluation.ball.opponent_with_ball()), 'not much going on') for state in [s2 for s2 in non_chill_states if s2 != Goalie.State.block]: self.add_transition( state, Goalie.State.block, lambda: not evaluation.ball.is_in_our_goalie_zone() and not evaluation.ball.is_moving_towards_our_goal() and self.robot_is_facing_our_goal(evaluation.ball.opponent_with_ball()), "opponents have possession")
def execute_marking(self): move = self.subbehavior_with_name('move') move.pos = self.move_target left_seg = robocup.Segment( robocup.Point(-constants.Field.PenaltyLongDist / 2, 0), robocup.Point(-constants.Field.PenaltyLongDist / 2, constants.Field.PenaltyShortDist)) right_seg = robocup.Segment( robocup.Point(constants.Field.PenaltyLongDist / 2, 0), robocup.Point(constants.Field.PenaltyLongDist / 2, constants.Field.PenaltyShortDist)) top_seg = robocup.Segment( robocup.Point(-constants.Field.PenaltyLongDist / 2, constants.Field.PenaltyShortDist), robocup.Point(constants.Field.PenaltyLongDist / 2, constants.Field.PenaltyShortDist)) if move.pos is not None: main.system_state().draw_circle(move.pos, 0.02, constants.Colors.Green, "Mark") main.system_state().draw_segment(left_seg, constants.Colors.Green, "Mark") main.system_state().draw_segment(top_seg, constants.Colors.Green, "Mark") main.system_state().draw_segment(right_seg, constants.Colors.Green, "Mark") # make the defender face the threat it's defending against if (self.robot is not None and self.block_line is not None): self.robot.face(self.block_line.get_pt(0)) if self.robot.has_ball() and not main.game_state().is_stopped(): self.robot.kick(0.75)
def score(cls): gs = main.game_state() if gs.is_ready_state() and gs.is_our_direct() and main.ball().pos.y > ( constants.Field.Length - 1.0): return 1 else: return float("inf")
def __init__(self): super().__init__(continuous=True) for state in Placement.State: self.add_state(state, behavior.Behavior.State.running) self.add_transition(behavior.Behavior.State.start, Placement.State.placing, lambda: True, 'immediately') self.add_transition(Placement.State.placing, Placement.State.reset, lambda: self.check_update(), 'command changed') self.add_transition(Placement.State.reset, Placement.State.placing, lambda: True, 'immediately') self._pos = main.game_state().get_ball_placement_point() self._our_restart = main.game_state().is_our_restart()
def __init__(self): super().__init__(start_state=DoubleTouchTracker.State.start) for state in DoubleTouchTracker.State: self.add_state(state) # FIXME: is it only restart plays? self.add_transition( DoubleTouchTracker.State.start, DoubleTouchTracker.State.restart_play_began, lambda: (main.root_play().play != None and main.root_play().play.__class__. is_restart() and main.game_state().is_our_restart()), 'we start running an offensive restart play') self.add_transition( DoubleTouchTracker.State.restart_play_began, DoubleTouchTracker.State.kicking, lambda: any(bot.has_ball() for bot in main.our_robots()), 'one of our bots has the ball') self.add_transition(DoubleTouchTracker.State.kicking, DoubleTouchTracker.State.kicker_forbidden, lambda: not self.kicker_has_possession(), 'kicker kicks or fumbles ball') self.add_transition(DoubleTouchTracker.State.kicker_forbidden, DoubleTouchTracker.State.other_robot_touched, lambda: self.other_robot_touching_ball(), 'another robot has touched the ball')
def __init__(self): super().__init__(continuous=True) for state in TheirShootOut.State: self.add_state(state, behavior.Behavior.State.running) self.add_transition(behavior.Behavior.State.start, TheirShootOut.State.starting, lambda: True, 'immediately') self.add_transition(TheirShootOut.State.starting, TheirShootOut.State.block, lambda: main.game_state().is_playing(), 'block') #go intercept if enemy robot doesn't have the ball or is within chip range self.add_transition(TheirShootOut.State.block, TheirShootOut.State.intercept, lambda: not self.has_ball(), 'intercept') #go back to blocking if the robot reclaims control of the ball and is outside chip range. self.add_transition( TheirShootOut.State.intercept, TheirShootOut.State.block, lambda: self.has_ball() and not self.in_chip_distance(), 'reblock') self.add_transition( TheirShootOut.State.block, TheirShootOut.State.capture, lambda: self.in_chip_distance() and self.has_ball(), 'capture') self.add_transition( TheirShootOut.State.intercept, TheirShootOut.State.capture, lambda: self.in_chip_distance() and self.has_ball(), 'capture') self.block_percentage = .50 self.chip_distance = 3.0 self.ball_lost_distance = 0.5
def execute_marking(self): move = self.subbehavior_with_name('move') move.pos = self.move_target left_seg = robocup.Segment( robocup.Point(-constants.Field.PenaltyLongDist / 2, 0), robocup.Point(-constants.Field.PenaltyLongDist / 2, constants.Field.PenaltyShortDist)) right_seg = robocup.Segment( robocup.Point(constants.Field.PenaltyLongDist / 2, 0), robocup.Point(constants.Field.PenaltyLongDist / 2, constants.Field.PenaltyShortDist)) top_seg = robocup.Segment( robocup.Point(-constants.Field.PenaltyLongDist / 2, constants.Field.PenaltyShortDist), robocup.Point(constants.Field.PenaltyLongDist / 2, constants.Field.PenaltyShortDist)) if move.pos is not None: main.system_state().draw_circle(move.pos, 0.02, constants.Colors.Green, "Mark") main.system_state().draw_segment(left_seg, constants.Colors.Green, "Mark") main.system_state().draw_segment(top_seg, constants.Colors.Green, "Mark") main.system_state().draw_segment(right_seg, constants.Colors.Green, "Mark") # make the defender face the threat it's defending against if (self.robot is not None and self.block_line is not None): self.robot.face(self.block_line.get_pt(0)) if self.robot.has_ball() and not main.game_state().is_stopped() and not self._self_goal(self.robot): self.robot.kick(0.75)
def __init__(self): super().__init__(continuous=False) self.pause_time = 0 for substate in OurPlacement.State: self.add_state(substate, behavior.Behavior.State.running) self.add_transition(behavior.Behavior.State.start, OurPlacement.State.dribble, lambda: True, 'immediately') #place the ball in the target area self.add_transition( OurPlacement.State.dribble, OurPlacement.State.pause, lambda: self.subbehavior_with_name('dribble').state == behavior.Behavior.State.completed, 'finished dribbling') self.add_transition(OurPlacement.State.pause, OurPlacement.State.avoid, lambda: time.time() - self.pause_time >= 1, 'pause for 1 seconds') #if the ball comes out of the target area, put it back self.add_transition( OurPlacement.State.avoid, OurPlacement.State.dribble, lambda: (main.ball().pos - main.game_state().get_ball_placement_point()).mag() > 0.1, 'ball moved out of target area')
def __init__(self): super().__init__(start_state=DoubleTouchTracker.State.start) for state in DoubleTouchTracker.State: self.add_state(state) # FIXME: is it only restart plays? self.add_transition(DoubleTouchTracker.State.start, DoubleTouchTracker.State.restart_play_began, lambda: (main.root_play().play != None and main.root_play().play.__class__.is_restart() and main.game_state().is_our_restart()), 'we start running an offensive restart play') self.add_transition(DoubleTouchTracker.State.restart_play_began, DoubleTouchTracker.State.kicking, lambda: any(bot.has_ball() for bot in main.our_robots()), 'one of our bots has the ball') self.add_transition(DoubleTouchTracker.State.kicking, DoubleTouchTracker.State.kicker_forbidden, lambda: not self.kicker_has_possession(), 'kicker kicks or fumbles ball') self.add_transition(DoubleTouchTracker.State.kicker_forbidden, DoubleTouchTracker.State.other_robot_touched, lambda: self.other_robot_touching_ball(), 'another robot has touched the ball')
def __init__(self): super().__init__(continuous=False) self._kicker_shell_id = None for state in OurKickoff.State: self.add_state(state, behavior.Behavior.State.running) self.add_transition(behavior.Behavior.State.start, OurKickoff.State.setup, lambda: True, 'immediately') self.add_transition(OurKickoff.State.setup, OurKickoff.State.kick, lambda: not main.game_state().is_setup_state(), "referee leaves setup") self.add_transition( OurKickoff.State.kick, behavior.Behavior.State.completed, lambda: self.has_subbehavior_with_name('kicker') and self.subbehavior_with_name('kicker').is_done_running(), "kicker finished") # TODO: verify that these values are right - I'm fuzzy on my matrix multiplication... idle_positions = [ robocup.Point(0.7, constants.Field.Length / 2.0 - 0.2), robocup.Point(-0.7, constants.Field.Length / 2.0 - 0.2) ] self.centers = [] for i, pos_i in enumerate(idle_positions): center_i = skills.move.Move(pos_i) self.add_subbehavior(center_i, 'center' + str(i), required=False, priority=4 - i) self.centers.append(center_i)
def should_clear_ball(self): if main.game_state().is_stopped(): return False #Returns true if our robot can reach the ball sooner than the closest opponent safe_to_clear = False if main.ball().pos.mag() < constants.Field.ArcRadius * 2 and main.ball( ).vel.mag() < .75 and not evaluation.ball.is_in_our_goalie_zone(): defender1 = self.subbehavior_with_name('defender1') defender2 = self.subbehavior_with_name('defender2') if (defender1.robot != None and defender2.robot != None): max_vel = robocup.MotionConstraints.MaxRobotSpeed.value max_accel = robocup.MotionConstraints.MaxRobotAccel.value for robot in main.system_state().their_robots: their_dist_to_ball = robot.pos.dist_to(main.ball().pos) #if their robot is moving faster than ours, assume it is at its maximum speed, otherwise assume its max speed is the same as ours their_max_vel = max(max_vel, robot.vel.mag()) #calculate time for the closest opponent to reach ball based on current /vel/pos data * .9 for safety their_time_to_ball = ( their_dist_to_ball / their_max_vel) * defender1.safety_multiplier if their_time_to_ball > evaluation.ball.time_to_ball( defender1.robot ) or their_time_to_ball > evaluation.ball.time_to_ball( defender2.robot): safe_to_clear = True return safe_to_clear
def score(cls): gs = main.game_state() if len(main.our_robots()) < 5: return float("inf") if (gs.is_ready_state() and gs.is_our_free_kick() and main.ball().pos.y > (constants.Field.Length - 1.2) and abs(main.ball().pos.x) > .6): return 0 else: return 10000
def setupStates(self): self.gameState = main.game_state() self.systemState = main.system_state() self.context = main.context() for g in self.systemState.our_robots: self.robotList.append(g) for g in self.systemState.their_robots: self.robotList.append(g) self.updateRobotList()
def __init__(self, indirect=None): super().__init__(continuous=True) # If we are indirect we don't want to shoot directly into the goal gs = main.game_state() if indirect != None: self.indirect = indirect elif main.ball().pos.y > constants.Field.Length / 2.0: self.indirect = gs.is_indirect() else: self.indirect = False self.add_transition(behavior.Behavior.State.start, behavior.Behavior.State.running, lambda: True, 'immediately') # FIXME: this could also be a PivotKick kicker = skills.line_kick.LineKick() # kicker.use_chipper = True kicker.min_chip_range = 0.3 kicker.max_chip_range = 3.0 # This will be reset to something else if indirect on the first iteration kicker.target = constants.Field.TheirGoalSegment # add two 'centers' that just move to fixed points center1 = skills.move.Move(robocup.Point(0, 1.5)) self.add_subbehavior(center1, 'center1', required=False, priority=4) center2 = skills.move.Move(robocup.Point(0, 1.5)) self.add_subbehavior(center2, 'center2', required=False, priority=3) if self.indirect: receive_pt, target_point, probability = evaluation.touchpass_positioning.eval_best_receive_point( main.ball().pos) pass_behavior = tactics.coordinated_pass.CoordinatedPass( receive_pt, None, (kicker, lambda x: True), receiver_required=False, kicker_required=False, prekick_timeout=9) # We don't need to manage this anymore self.add_subbehavior(pass_behavior, 'kicker') kicker.target = receive_pt else: kicker = skills.line_kick.LineKick() kicker.target = constants.Field.TheirGoalSegment self.add_subbehavior(kicker, 'kicker', required=False, priority=5) self.add_transition( behavior.Behavior.State.running, behavior.Behavior.State.completed, lambda: self.subbehavior_with_name('kicker').is_done_running() and self.subbehavior_with_name('kicker').state != tactics.coordinated_pass.CoordinatedPass.State.timeout, 'kicker completes')
def __init__(self, indirect=None): super().__init__(continuous=True) # If we are indirect we don't want to shoot directly into the goal gs = main.game_state() if indirect is not None: self.indirect = indirect elif main.ball().pos.y > constants.Field.Length / 2.0: self.indirect = gs.is_indirect() else: self.indirect = False self.add_transition(behavior.Behavior.State.start, behavior.Behavior.State.running, lambda: True, 'immediately') # FIXME: this could also be a PivotKick kicker = skills.line_kick.LineKick() # kicker.use_chipper = True kicker.min_chip_range = 0.3 kicker.max_chip_range = 3.0 # This will be reset to something else if indirect on the first iteration kicker.target = constants.Field.TheirGoalSegment # add two 'centers' that just move to fixed points center1 = skills.move.Move(robocup.Point(0, 1.5)) self.add_subbehavior(center1, 'center1', required=False, priority=4) center2 = skills.move.Move(robocup.Point(0, 1.5)) self.add_subbehavior(center2, 'center2', required=False, priority=3) if self.indirect: receive_pt, target_point, probability = evaluation.touchpass_positioning.eval_best_receive_point( main.ball().pos) pass_behavior = tactics.coordinated_pass.CoordinatedPass( receive_pt, None, (kicker, lambda x: True), receiver_required=False, kicker_required=False, prekick_timeout=9) # We don't need to manage this anymore self.add_subbehavior(pass_behavior, 'kicker') kicker.target = receive_pt else: kicker = skills.line_kick.LineKick() kicker.target = constants.Field.TheirGoalSegment self.add_subbehavior(kicker, 'kicker', required=False, priority=5) self.add_transition( behavior.Behavior.State.running, behavior.Behavior.State.completed, lambda: self.subbehavior_with_name('kicker').is_done_running() and self.subbehavior_with_name('kicker').state != tactics.coordinated_pass.CoordinatedPass.State.timeout, 'kicker completes')
def score(cls): gs = main.game_state() # enter play when doing a corner kick or stay in it even if we manipulate the ball if OurIndirectPivot.Running or (gs.is_ready_state() and (gs.is_our_direct() or gs.is_our_indirect()) and main.ball().pos.y < (constants.Field.Length - 1.2)): OurIndirectPivot.Running = True return 0 else: return float("inf")
def minimax(board, depth=4, sense=1, alpha=float("-inf"), beta=float("inf")): """ Minimax algorithm looking multiple moves ahead to determine optimal moves. Uses alpha-beta pruning. :param board: current board state :param depth: number of turns ahead to look :param sense: determines whether player is minimizing or maximizing score :param alpha: lower bound for maximum score :param beta: upper bound for minimum score :return: optimal move """ if game_state(board) == "draw": return [[], 0] elif game_state(board) == turn(board): return [[], (1000 + depth) * sense] elif game_state(board) == opp(board): return [[], (-1000 + depth) * sense] elif depth == 0: score = 0 if two(board, turn(board)): score += 100 * sense if two(board, opp(board)): score -= 100 * sense return [[], score] best_move = [] result = float('inf') * -sense for move in find_moves(board): b = board.copy_board() Player().make_move(b, move) curr = minimax(b, depth - 1, -sense, alpha, beta)[1] if curr > result and sense == 1 or curr < result and sense == -1: best_move, result = move, curr if sense == 1: alpha = max(alpha, curr) else: beta = min(beta, curr) if alpha >= beta: break return [best_move, result]
def __init__(self): super().__init__(continuous=False) for substate in Penalty.State: self.add_state(substate, behavior.Behavior.State.running) self.add_transition(behavior.Behavior.State.start, Penalty.State.waiting, lambda: True, 'immediately') self.add_transition(Penalty.State.waiting, Penalty.State.setup, lambda: main.game_state().is_setup_state(), 'ref says time to setup') for state in [Penalty.State.waiting, Penalty.State.setup]: self.add_transition(state, Penalty.State.ready, lambda: main.game_state().is_ready_state(), 'ref says ready') self.add_transition( Penalty.State.ready, behavior.Behavior.State.completed, lambda: self.subbehavior_with_name('kick').state == behavior. Behavior.State.completed, 'done kicking')
def __init__(self): super().__init__(start_state=DoubleTouchTracker.State.start) for state in DoubleTouchTracker.State: self.add_state(state) # FIXME: is it only restart plays? self.add_transition( DoubleTouchTracker.State.start, DoubleTouchTracker.State.restart_play_began, lambda: (main.root_play().play is not None and main.root_play().play. __class__.is_restart() and main.game_state().is_our_restart()), 'we start running an offensive restart play') self.add_transition( DoubleTouchTracker.State.restart_play_began, DoubleTouchTracker.State.kicking, lambda: ( (any(self._touching_ball(bot) for bot in main.our_robots())) or main.game_state( ).is_playing()) and not main.game_state().is_placement(), 'one of our bots has the ball or the ball was kicked') self.add_transition( DoubleTouchTracker.State.kicking, DoubleTouchTracker.State.kicker_forbidden, # The ball is no longer in restart, we have begun playing ( lambda: main.game_state().is_playing() or # We aren't in a restart anymore main.root_play().play is None or not main.root_play().play. __class__.is_restart()), 'ball has moved and is now in play') self.add_transition(DoubleTouchTracker.State.kicker_forbidden, DoubleTouchTracker.State.other_robot_touched, lambda: self.other_robot_touching_ball(), 'another robot has touched the ball')
def __init__(self): super().__init__(continuous=True) for s in OurShootoutKick.State: self.add_state(s, behavior.Behavior.State.running) self.add_transition(behavior.Behavior.State.start, OurShootoutKick.State.starting, lambda: True, 'immediately') # begin to kick as soon as given the ready signal self.add_transition(OurShootoutKick.State.starting, OurShootoutKick.State.shooting, lambda: main.game_state().is_ready_state(), 'shoot when given the ready signal')
def __init__(self): super().__init__(continuous=True) #initalize states for s in OurShootoutChip.State: self.add_state(s, behavior.Behavior.State.running) # add transition to lead into the first state (starting/setup state) self.add_transition(behavior.Behavior.State.start, OurShootoutChip.State.starting, lambda: True, 'immediately') # one the ball is able to be hit begin dribbling a meter up self.add_transition(OurShootoutChip.State.starting, OurShootoutChip.State.dribbling, lambda: main.game_state().is_ready_state(), 'begin') # if the goalie gets too close chip over him self.add_transition(OurShootoutChip.State.dribbling, OurShootoutChip.State.chipping, lambda: self.is_goalie_close(), 'goalie in range') # if the goalie is not too close and we reach a "must shoot time" (since we only have 10s) # just kick the ball into goal self.add_transition( OurShootoutChip.State.dribbling, OurShootoutChip.State.shooting, lambda: not self.is_goalie_close() and self.must_shoot_time(), 'must shoot') # if the ball fails to go in after a chip try to capture self.add_transition( OurShootoutChip.State.chipping, OurShootoutChip.State.capture, lambda: self.has_subbehavior_with_name( 'chipping') and self.subbehavior_with_name('chipping').state == behavior.Behavior.State.completed, 'recapture') # after you capture shoot the ball with a kick self.add_transition( OurShootoutChip.State.capture, OurShootoutChip.State.shooting, lambda: self.subbehavior_with_name('capture').state == behavior. Behavior.State.completed, 'reshoot') self.total_time = 10.0 self.shoot_time = 6.0 self.start_time = time.time() self.chip_distance = 1.5 self.goalie_range = 2
def should_clear_ball(self): if main.game_state().is_stopped(): return False safe_to_clear = False if (abs(main.ball().pos.x) < constants.Field.PenaltyLongDist and main.ball().pos.y < constants.Field.PenaltyShortDist * 2 and main.ball().vel.mag() < .75 and not evaluation.ball.is_in_our_goalie_zone()): defender1 = self.subbehavior_with_name('defender1') defender2 = self.subbehavior_with_name('defender2') if (defender1.robot != None and defender2.robot != None): defenders = [defender1.robot, defender2.robot] # See if we can reach the ball before them safe_to_clear, bot_to_clear = evaluation.path.can_collect_ball_before_opponent( our_robots_to_check=defenders) return safe_to_clear
def __init__(self): super().__init__(continuous=False) self._kicker_shell_id = None for state in OurKickoff.State: self.add_state(state, behavior.Behavior.State.running) self.add_transition(behavior.Behavior.State.start, OurKickoff.State.setup, lambda: True, 'immediately') self.add_transition(OurKickoff.State.setup, OurKickoff.State.kick, lambda: not main.game_state().is_setup_state(), "referee leaves setup") self.add_transition( OurKickoff.State.kick, behavior.Behavior.State.completed, lambda: self.has_subbehavior_with_name('kicker') and self. subbehavior_with_name('kicker').is_done_running(), "kicker finished") # TODO: verify that these values are right - I'm fuzzy on my matrix multiplication... idle_positions = [ robocup.Point(0.7, constants.Field.Length / 2.0 - 0.2), robocup.Point(-0.7, constants.Field.Length / 2.0 - 0.2) ] self.centers = [] for i, pos_i in enumerate(idle_positions): center_i = skills.move.Move(pos_i) self.add_subbehavior(center_i, 'center' + str(i), required=False, priority=4 - i) self.centers.append(center_i) self.add_subbehavior(tactics.defense.Defense(), 'defense', required=False)
def __init__(self): super().__init__(continuous=True) self.debug = False self.add_transition(behavior.Behavior.State.start, behavior.Behavior.State.running, lambda: True, 'immediately') self.marks = [] if (main.game_state().is_their_direct()): self.intercept = (constants.Field.OurGoalSegment.center() - main.ball().pos) * 0.25 + main.ball().pos self.add_subbehavior(skills.move.Move(self.intercept), 'intercept direct', required=False, priority=5) for i in range(3): mark_i = skills.mark.Mark() mark_i.ratio = 0.7 self.add_subbehavior(mark_i, 'mark' + str(i), required=False, priority=3 - i) self.marks.append(mark_i) self.kick_eval = robocup.KickEvaluator(main.system_state()) self.kick_eval.debug = True for i, robot in enumerate(main.our_robots()): self.kick_eval.add_excluded_robot(robot) for i, robot in enumerate(main.their_robots()): self.kick_eval.add_excluded_robot(robot) their_kicker = min(main.their_robots(), key=lambda opp: opp.pos.dist_to(main.ball().pos)) self.kick_eval.add_excluded_robot(their_kicker)
def execute_marking(self): move = self.subbehavior_with_name('move') move.pos = self.move_target arc_left = robocup.Arc( robocup.Point(-constants.Field.GoalFlat / 2, 0), constants.Field.ArcRadius + constants.Robot.Radius * 2, math.pi / 2, math.pi) arc_right = robocup.Arc( robocup.Point(constants.Field.GoalFlat / 2, 0), constants.Field.ArcRadius + constants.Robot.Radius * 2, 0, math.pi / 2) seg = robocup.Segment( robocup.Point( -constants.Field.GoalFlat / 2, constants.Field.ArcRadius + constants.Robot.Radius * 2), robocup.Point( constants.Field.GoalFlat / 2, constants.Field.ArcRadius + constants.Robot.Radius * 2)) if move.pos is not None: main.system_state().draw_circle(move.pos, 0.02, constants.Colors.Green, "Mark") main.system_state().draw_segment(seg, constants.Colors.Green, "Mark") main.system_state().draw_arc(arc_left, constants.Colors.Green, "Mark") main.system_state().draw_arc(arc_right, constants.Colors.Green, "Mark") # make the defender face the threat it's defending against if (self.robot is not None and self.block_line is not None): self.robot.face(self.block_line.get_pt(0)) if self.robot.has_ball() and not main.game_state().is_stopped(): self.robot.kick(0.75)
def execute_running(self): # update double touch tracker evaluation.double_touch.tracker().spin() # cache and calculate the score() function for each play class main.play_registry().recalculate_scores() # Play Selection ################################################################################ if main.game_state().is_stopped(): if not isinstance(self.play, plays.stopped.Stopped): logging.info("Running 'Stopped' play due to game state change") self.play = plays.stopped.Stopped() self._currently_restarting = True elif main.game_state().is_halted(): self.play = None else: # (play_class, score value) tuples enabled_plays_and_scores = [p for p in main.play_registry().get_enabled_plays_and_scores()] # only let restart play run once enabled_plays_and_scores = [p for p in enabled_plays_and_scores if not p[0].is_restart() or ( p[0].is_restart() and self._currently_restarting)] # handle temporary blacklisting # we remove the blacklisted play class from selection for this iteration, then unblacklist it enabled_plays_and_scores = [p for p in enabled_plays_and_scores if p[0] != self.temporarily_blacklisted_play_class] self.temporarily_blacklisted_play_class = None # see if we need to kill current play or if it's done running if self.play != None: if self.play.__class__ not in map(lambda tup: tup[0], enabled_plays_and_scores): logging.info("Current play '" + self.play.__class__.__name__ + "' no longer enabled, aborting") self.play.terminate() self.play = None elif self.play.is_done_running(): logging.info("Current play '" + self.play.__class__.__name__ + "' finished running") if self.play.is_restart: self._currently_restarting = False self.play = None elif self.play.__class__.score() == float("inf"): logging.info("Current play '" + self.play.__class__.__name__ + "' no longer applicable, ending") self.play.terminate() self.play = None if self.play == None: # reset the double-touch tracker evaluation.double_touch.tracker().restart() try: if len(enabled_plays_and_scores) > 0: # select the play with the smallest value for score() play_class_and_score = min(enabled_plays_and_scores, key=lambda tup: tup[1]) # run the play with the lowest score, as long as it isn't inf if play_class_and_score[1] != float("inf"): play_class = play_class_and_score[0] self.play = play_class() # instantiate it else: # there's no available plays to run pass except Exception as e: logging.error("Exception occurred during play selection: " + str(e)) traceback.print_exc() if self.play != None: logging.info("Chose new play: '" + self.play.__class__.__name__ + "'") # Role Assignment ################################################################################ try: assignments = role_assignment.assign_roles(self.robots, self.role_requirements()) except role_assignment.ImpossibleAssignmentError as e: logging.error("Unable to satisfy role assignment constraints. Dropping and temp. blacklisting current play...") self.drop_current_play(temporarily_blacklist=True) else: self.assign_roles(assignments)
def score(cls): if main.game_state().is_playing(): return 9 return float("inf")
def score(cls): return 0 if main.game_state().is_stopped() else float("inf")
def score(cls): gs = main.game_state() return 0 if gs.is_ready_state() and ( gs.is_their_free_kick() or gs.is_their_indirect() or gs.is_their_direct()) else float("inf")
def score(cls): gs = main.game_state() return 0 if gs.is_our_placement() else float("inf")
def __init__(self): super().__init__(continuous=True) for substate in Goalie.State: self.add_state(substate, behavior.Behavior.State.running) self.add_transition(behavior.Behavior.State.start, Goalie.State.chill, lambda: True, "immediately") self.add_transition(Goalie.State.chill, Goalie.State.defend, lambda: main.ball().valid, "ball is valid") non_chill_states = [s for s in Goalie.State if s != Goalie.State.chill] # if ball is invalid, chill for state in non_chill_states: self.add_transition(state, Goalie.State.chill, lambda: not main.ball().valid, "ball is invalid") for state in non_chill_states: self.add_transition( state, Goalie.State.setup_penalty, lambda: main.game_state( ).is_their_penalty() and main.game_state().is_setup_state(), "setting up for opponent penalty") for state in [ s2 for s2 in non_chill_states if s2 != Goalie.State.intercept ]: self.add_transition( state, Goalie.State.intercept, lambda: evaluation.ball.is_moving_towards_our_goal( ) and not self.robot_is_facing_our_goal(evaluation.ball. opponent_with_ball()), "ball coming towards our goal") for state in [ s2 for s2 in non_chill_states if s2 != Goalie.State.clear ]: self.add_transition( state, Goalie.State.clear, lambda: evaluation.ball.is_in_our_goalie_zone( ) and not main.game_state().is_their_penalty( ) and not evaluation.ball.is_moving_towards_our_goal( ) and evaluation.ball.opponent_with_ball() is None, "ball in our goalie box, but not headed toward goal") for state in [ s2 for s2 in non_chill_states if s2 != Goalie.State.defend ]: self.add_transition( state, Goalie.State.defend, lambda: not evaluation.ball.is_in_our_goalie_zone( ) and not evaluation.ball.is_moving_towards_our_goal( ) and not main.game_state().is_their_penalty() and not self. robot_is_facing_our_goal(evaluation.ball.opponent_with_ball()), 'not much going on') for state in [ s2 for s2 in non_chill_states if s2 != Goalie.State.block ]: self.add_transition( state, Goalie.State.block, lambda: not evaluation.ball.is_in_our_goalie_zone() and not evaluation.ball.is_moving_towards_our_goal() and self. robot_is_facing_our_goal(evaluation.ball.opponent_with_ball()), "opponents have possession")
def score(cls): gs = main.game_state() return 0 if gs.is_our_kickoff() else float("inf")
def on_enter_dribble(self): dribble = skills.dribble.Dribble( main.game_state().get_ball_placement_point()) self.add_subbehavior(dribble, 'dribble', required=True, priority=100)
def score(cls): gs = main.game_state() return 0 if (gs.is_ready_state() and gs.is_our_direct() and main.ball().pos.y < 1.0) else float("inf")
def score(cls): gs = main.game_state() if ((gs.is_setup_state() or not main.game_state().is_playing()) and gs.is_their_kickoff()): return 0 return float("inf")
def score(cls): if (not main.game_state().is_playing()): return float("inf") if len(main.our_robots()) < 5: return float("inf") return 10
def score(cls): gs = main.game_state() #This play does not work well against functional opponent robots, maybe add #"and len(main.system_state().their_robots)==0" or some kind of check for nonmoving opponents? return 1 if gs.is_playing() else float("inf")
def score(cls): gs = main.game_state() return 0 if behavior.Behavior.State.running or ( gs.is_ready_state() and gs.is_our_indirect_kick()) else float("inf")
def score(cls): gs = main.game_state() return 0 if gs.is_their_penalty() and gs.is_setup_state() else float( "inf")
def on_enter_reset(self): self._pos = main.game_state().get_ball_placement_point() self._our_restart = main.game_state().is_our_restart()
def execute_running(self): # update double touch tracker evaluation.double_touch.tracker().spin() # cache and calculate the score() function for each play class main.play_registry().recalculate_scores() # Play Selection ################################################################################ if main.game_state().is_stopped(): evaluation.double_touch.tracker().restart() if main.game_state().is_placement(): if not isinstance(self.play, plays.restarts.placement.Placement): logging.info("Placing Ball") self.play = plays.restarts.placement.Placement() self._currently_restarting = True else: if self.play is None or not self.play.run_during_stopped(): logging.info( "Running 'Stopped' play due to game state change") self.play = plays.stopped.Stopped() self._currently_restarting = True elif main.game_state().is_halted(): evaluation.double_touch.tracker().restart() self.play = None else: # (play_class, score value) tuples enabled_plays_and_scores = [ p for p in main.play_registry().get_enabled_plays_and_scores() ] # only let restart play run once enabled_plays_and_scores = [ p for p in enabled_plays_and_scores if not p[0].is_restart() or ( p[0].is_restart() and self._currently_restarting) ] # handle temporary blacklisting # we remove the blacklisted play class from selection for this iteration, then unblacklist it enabled_plays_and_scores = [ p for p in enabled_plays_and_scores if p[0] != self.temporarily_blacklisted_play_class ] self.temporarily_blacklisted_play_class = None # see if we need to kill current play or if it's done running if self.play is not None: if self.play.__class__ not in map(lambda tup: tup[0], enabled_plays_and_scores): logging.info("Current play '" + self.play.__class__.__name__ + "' no longer enabled, aborting") self.play.terminate() self.play = None elif self.play.is_done_running(): logging.info("Current play '" + self.play.__class__.__name__ + "' finished running") if self.play.is_restart: self._currently_restarting = False self.play = None elif self.play.__class__.score() == float("inf"): logging.info("Current play '" + self.play.__class__.__name__ + "' no longer applicable, ending") self.play.terminate() self.play = None if self.play is None: try: if len(enabled_plays_and_scores) > 0: # select the play with the smallest value for score() play_class_and_score = min(enabled_plays_and_scores, key=lambda tup: tup[1]) # run the play with the lowest score, as long as it isn't inf if play_class_and_score[1] != float("inf"): play_class = play_class_and_score[0] self.play = play_class() # instantiate it else: # there's no available plays to run pass except Exception as e: logging.error( "Exception occurred during play selection: " + str(e)) traceback.print_exc() if self.play is not None: logging.info("Chose new play: '" + self.play.__class__.__name__ + "'") # Role Assignment ################################################################################ try: assignments = role_assignment.assign_roles( self.robots, self.role_requirements()) except role_assignment.ImpossibleAssignmentError as e: logging.error( "Unable to satisfy role assignment constraints. Dropping and temp. blacklisting current play..." ) self.drop_current_play(temporarily_blacklist=True) else: self.assign_roles(assignments)
def score(cls): return 10 if main.game_state().is_playing() else float("inf")
def score(cls): gs = main.game_state() return 0 if gs.is_ready_state() and gs.is_our_free_kick() else float( "inf")