 |
GT RoboCup SSL
Soccer software, robot firmware
|
|
GT RoboCup SSL
Soccer software, robot firmware
|
lines up with the ball and the target, then drives up and kicks this differs from PivotKick which gets the ball first, then aims Note: LineKickOld recalculates the target_aim_point ONLY when the target point/segment changes More...
Classes | |
| class | State |
Public Member Functions | |
| def | __init__ (self) |
| def | drive_around_dist (self) |
| We use the path planner to move to a point this distance away from the ball and on the opposite side of where we're aiming. | |
| def | drive_around_dist (self, value) |
| def | setup_ball_avoid (self) |
| The avoid ball radius for while we're getting to the setup point. | |
| def | setup_ball_avoid (self, value) |
| def | robot_is_between_ball_and_target (self) |
| def | recalculate (self) |
| def | on_exit_start (self) |
| def | execute_running (self) |
| def | execute_setup (self) |
| def | execute_charge (self) |
| def | role_requirements (self) |
 Public Member Functions inherited from gameplay.skills._kick._Kick | |
| def | __init__ (self) |
| def | use_windowing (self) |
| if True, uses the window evaluator to choose the best place to aim at target_segment Default: True | |
| def | use_windowing (self, value) |
| def | win_eval_params (self) |
| these params are passed to the window evaluator using setattr() Default: {} | |
| def | win_eval_params (self, value) |
| def | target (self) |
| The thing we're trying to kick at can be a Segment or a Point setting this property automatically recalculates the target_aim_point Default: the opponent's goal segment. | |
| def | target (self, value) |
| def | shot_obstacle_ignoring_robots (self) |
| A list of robots that the shot obstacle doesn't apply to Note: the shot obstacle already doesn't apply to the kicker, you don't have to specify that here Default: []. | |
| def | shot_obstacle_ignoring_robots (self, value) |
| def | aim_target_point (self) |
| We calculate the point we're ACTUALLY going to aim at based on the target Segment/Point and other parameters This is that point. | |
| def | current_shot_point (self) |
| Generic compatibility with pivot_kick This method should be overriden if possible. | |
| def | is_steady (self) |
| Generic compatibilty with pivot_kick This method should be overriden if possible. | |
| def | recalculate_aim_target_point (self) |
| we're aiming at a particular point on our target segment, what is this point? | |
| def | kick_power (self) |
| Allows for different kicker/chipper settings, such as for passing with lower power. More... | |
| def | kick_power (self, value) |
| def | chip_power (self) |
| def | chip_power (self, value) |
| def | use_chipper (self) |
| If false, uses straight kicker, if true, uses chipper (if available) Default: False. | |
| def | use_chipper (self, value) |
| def | enable_kick (self) |
| If set to False, will get all ready to go, but won't kick/chip just yet Can be used to synchronize between behaviors Default: True. | |
| def | enable_kick (self, value) |
| def | add_shot_obstacle (self, excluded_robots=[]) |
| creates a polygon obstacle from the ball to the target this obstacle applies to all robots except the kicker and anything specified in the excluded_robots parameter NOTE: this method is not called by _kick, it's up to subclasses/superbehaviors to call it | |
| def | execute_running (self) |
| Public Member Functions inherited from gameplay.single_robot_behavior.SingleRobotBehavior | |
| def | __init__ (self, continuous) |
| def | execute_running (self) |
| def | role_requirements (self) |
| def | assign_roles |
| def | __str__ (self) |
| Public Member Functions inherited from gameplay.behavior.Behavior | |
| def | __init__ |
| def | add_state (self, state, parent_state=None) |
| def | is_done_running (self) |
| def | terminate (self) |
| Transitions the Behavior into a terminal state (either completed or cancelled) | |
| def | behavior_state (self) |
| returns a state in Behavior.State that represents what the behaviors is doing use this instead of the property if you want to avoid dealing with custom subclass substates | |
| def | is_continuous (self) |
| The Behavior's termination behavior noncontinuous: a behavior that accomplishes a specific task, then completes (example: shooting at the goal) continuous: a behavior that continually runs until told to stop (example: zone defense) | |
| def | __str__ (self) |
| def | role_requirements (self) |
| Returns a tree of RoleRequirements keyed by subbehavior reference name This is used by the dynamic role assignment system to intelligently select which robot will run which behavior. | |
| def | assign_roles (self, assignments) |
| assignments is a tree of (RoleRequirements, OurRobot) tuples Same tree structure as the role_requirements() return value, but tuples instead of RoleRequirements as leaf nodes | |
| Public Member Functions inherited from gameplay.fsm.StateMachine | |
| def | __init__ (self, start_state) |
| def | start_state (self) |
| def | restart (self) |
| Resets the FSM back into the start state. | |
| def | add_state (self, state, parent_state=None) |
| Registers a new state (which can optionally be a substate of an existing state) | |
| def | spin (self) |
| Runs the FSM checks transition conditions for all edges leading away from the current state if one evaluates to true, we transition to it if more than one evaluates to true, we throw a RuntimeError. | |
| def | add_transition |
| def | transition (self, new_state) |
| def | is_in_state (self, state) |
| def | state_is_substate (self, state, possible_parent) |
| def | corresponding_ancestor_state (self, ancestors) |
| def | ancestors_of_state (self, state) |
| def | as_graphviz (self) |
| def | write_diagram_png |
| def | state (self) |
Public Attributes | |
| setup_ball_avoid | |
| drive_around_dist | |
| Public Attributes inherited from gameplay.skills._kick._Kick | |
| enable_kick | |
| use_chipper | |
| kick_power | |
| chip_power | |
| use_windowing | |
| win_eval_params | |
| target | |
| shot_obstacle_ignoring_robots | |
| enable_shot_obstacle | |
| aim_params | |
| Public Attributes inherited from gameplay.single_robot_behavior.SingleRobotBehavior | |
| robot | |
Static Public Attributes | |
| float | DefaultDriveAroundDist = 0.15 |
| tuneable constants | |
| float | ChargeThresh = 0.1 |
| float | EscapeChargeThresh = 0.1 |
| float | DefaultSetupBallAvoid = 0.15 |
| float | AccelBias = 0.2 |
| int | FacingThresh = 10 |
| float | MaxChargeSpeed = 1.5 |
| float | BallProjectTime = 0.4 |
| float | DoneStateThresh = 0.11 |
| float | ClosenessThreshold = constants.Robot.Radius + 0.04 |
lines up with the ball and the target, then drives up and kicks this differs from PivotKick which gets the ball first, then aims Note: LineKickOld recalculates the target_aim_point ONLY when the target point/segment changes
LineKickOld is a version of LineKick implemented completely in python The current version of LineKick is implemented in the C++ to take advantage of path planning there. While they should produce the same end result, the new LineKick approaches the ball quicker and more accurately, while this one needs to remain more cautious (as it cannot interact directly with pathplanner)
Inheritance diagram for gameplay.skills.line_kick_old.LineKickOld: Collaboration diagram for gameplay.skills.line_kick_old.LineKickOld:
1.8.13 
