 |
GT RoboCup SSL
Soccer software, robot firmware
|
|
GT RoboCup SSL
Soccer software, robot firmware
|
A play coordinates the entire team of robots. More...
Public Member Functions | |
| def | __init__ (self, continuous) |
| def | score (cls) |
| Used to determine when to run a play Return float("inf") if the play cannot be used or a score (lower is better) used to select the best play. More... | |
| def | is_restart (cls) |
| def | handles_goalie (cls) |
| Override to opt-in to handling the Goalie By default, the root play allocates and runs the goalie behavior and the play handles the rest of the bots. More... | |
| def | run_during_stopped (cls) |
| Override to allow a play to run during the stopped state This is reserved only for very special plays that need to run during the stopped state. More... | |
 Public Member Functions inherited from gameplay.composite_behavior.CompositeBehavior | |
| def | __init__ |
| def | add_subbehavior |
| def | remove_subbehavior |
| def | has_subbehavior_with_name |
| def | has_subbehaviors (self) |
| def | subbehavior_with_name |
| def | subbehaviors_by_name (self) |
| def | remove_all_subbehaviors (self) |
| def | all_subbehaviors (self) |
| Returns a list of all subbehaviors. | |
| def | all_subbehaviors_completed (self) |
| def | spin (self) |
| Override StateMachine.spin() so we can call spin() on subbehaviors. | |
| def | handle_subbehavior_exception (self, name, exception) |
| Override point for exception handling this is called whenever a subbehavior throws an exception during spin() subclasses of CompositeBehavior can override this to perform custom actions, such as removing the offending subbehavior the default implementation logs the exception and re-raises it. | |
| def | role_requirements (self) |
| returns a tree of role_requirements | |
| def | assign_roles (self, assignments) |
| 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) |
A play coordinates the entire team of robots.
Only play runs at a time. By default, the RootPlay (which every Play is a subbehavior of) handles the Goalie, however, by overriding the handles_goalie() class method, a Play can choose to handle the goalie on its own, which allows for greater coordination.
Inheritance diagram for gameplay.play.Play: Collaboration diagram for gameplay.play.Play:| def gameplay.play.Play.handles_goalie | ( | cls | ) |
Override to opt-in to handling the Goalie By default, the root play allocates and runs the goalie behavior and the play handles the rest of the bots.
However, it is often better to let the play handle it so the goalie can coordinate better with the other bots on the field. In your play, override this method to return True to do the goalie-handling yourself Your play will read the goalie_id from root_play and setup some sort of goalie-ish behavior that that bot will fulfill Note: keep in mind that the global goalie_id can be None and it may change from time to time
| def gameplay.play.Play.run_during_stopped | ( | cls | ) |
Override to allow a play to run during the stopped state This is reserved only for very special plays that need to run during the stopped state.
Most plays should give up control during the stopped state to stopped.py, so stopped.py is the only play that should be overriding this.
| def gameplay.play.Play.score | ( | cls | ) |
Used to determine when to run a play Return float("inf") if the play cannot be used or a score (lower is better) used to select the best play.
1.8.13 
