# Option execute-kick Executes an appropiate kick action depending a the kick selection table Parameters of that option:
Parameter | Measure | Range | Description
execute-kick.action | int | 0.. | The action id of the kick that was selected
## State Machine ## State select
If that state is active,
> | The basic behavior do-nothing is executed.
> | These output symbols are set:
| head-control-mode | = | head-control-mode.search-for-ball
The decision tree:
Pseudo code of the decision tree:
if ( | ::execute-kick.action == action.nothing | ) | // no kick action possible
{
transition-to-state(finished);
}
else if ( | ::execute-kick.action == action.chest-soft | ) | // chest-soft possible
{
transition-to-state(chest-soft);
}
else if ( | ::execute-kick.action == action.chest-strong | ) | // chest-soft possible
{
transition-to-state(chest-strong);
}
else if ( | ::execute-kick.action == action.head-left | ) | // head-left possible
{
transition-to-state(head-left);
}
else if ( | ::execute-kick.action == action.head-right | ) | // head-right possible
{
transition-to-state(head-right);
}
else if ( | ::execute-kick.action == action.left-paw | ) | // left-paw possible
{
transition-to-state(left-paw);
}
else if ( | ::execute-kick.action == action.right-paw | ) | // right-paw possible
{
transition-to-state(right-paw);
}
else if ( | ::execute-kick.action == action.push-strong | ) | // push-strong possible
{
transition-to-state(push-strong);
}
else if ( | ::execute-kick.action == action.any-left | ) | // any-left possible
{
transition-to-state(any-left);
}
else if ( | ::execute-kick.action == action.any-right | ) | // any-right possible
{
transition-to-state(any-right);
}
else if ( | ::execute-kick.action == action.arm-right | ) | // arm-right possible
{
transition-to-state(arm-right);
}
else if ( | ::execute-kick.action == action.arm-left | ) | // arm-left possible
{
transition-to-state(arm-left);
}
else if ( | ::execute-kick.action == action.push-soft | ) | // push-soft possible
{
transition-to-state(push-soft);
}
else if ( | ::execute-kick.action == action.put-right | ) | // put-right possible
{
transition-to-state(put-right);
}
else if ( | ::execute-kick.action == action.put-left | ) | // put-left possible
{
transition-to-state(put-left);
}
else if ( | ::execute-kick.action == action.hook-right | ) | // hook-right possible
{
transition-to-state(hook-right);
}
else if ( | ::execute-kick.action == action.hook-left | ) | // hook-left possible
{
transition-to-state(hook-left);
}
else if ( | ::execute-kick.action == action.forward-kick-fast | ) | // forward-kick-fast possible
{
transition-to-state(forward-kick-fast);
}
else if ( | ::execute-kick.action == action.forward-kick-hard | ) | // forward-kick-hard possible
{
transition-to-state(forward-kick-hard);
}
else if ( | ::execute-kick.action == action.slap-right | ) | // slap-right possible
{
transition-to-state(slap-right);
}
else if ( | ::execute-kick.action == action.slap-left | ) | // slap-left possible
{
transition-to-state(slap-left);
}
else if ( | ::execute-kick.action == action.head-right-soft | ) | // head-right-soft possible
{
transition-to-state(head-right-soft);
}
else if ( | ::execute-kick.action == action.head-left-soft | ) | // head-left-soft possible
{
transition-to-state(head-left-soft);
}
else if ( | ::execute-kick.action == action.back-kick-left | ) | // back-kick-left possible
{
transition-to-state(back-kick-left);
}
else if ( | ::execute-kick.action == action.back-kick-right | ) | // back-kick-right possible
{
transition-to-state(back-kick-right);
}
else if ( | ::execute-kick.action == action.kick-along-arm-left | ) | // kick-along-arm-left possible
{
transition-to-state(kick-along-arm-left);
}
else if ( | ::execute-kick.action == action.kick-along-arm-right | ) | // kick-along-arm-right possible
{
transition-to-state(kick-along-arm-right);
}
else if ( | ::execute-kick.action == action.kick-with-back-leg-left | ) | // back-kick-right possible
{
transition-to-state(kick-with-back-leg-left);
}
else if ( | ::execute-kick.action == action.kick-with-back-leg-right | ) | // back-kick-right possible
{
transition-to-state(kick-with-back-leg-right);
}
else
{
transition-to-state(select);
}
## State chest-soft
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.chest-soft ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again);
}
else
{
transition-to-state(chest-soft);
}
## State chest-strong
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.chest-hard ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again);
}
else
{
transition-to-state(chest-strong);
}
## State head-left
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.head-left ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-left);
}
else
{
transition-to-state(head-left);
}
## State head-right
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.head-right ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-right);
}
else
{
transition-to-state(head-right);
}
## State left-paw
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.left-paw ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-left);
}
else
{
transition-to-state(left-paw);
}
## State right-paw
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.right-paw ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-right);
}
else
{
transition-to-state(right-paw);
}
## State push-strong
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.push-strong ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again);
}
else
{
transition-to-state(push-strong);
}
## State any-left
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.any-left ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-left);
}
else
{
transition-to-state(any-left);
}
## State any-right
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.any-right ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-right);
}
else
{
transition-to-state(any-right);
}
## State arm-right
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.arm-right ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-right);
}
else
{
transition-to-state(arm-right);
}
## State arm-left
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.arm-left ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-left);
}
else
{
transition-to-state(arm-left);
}
## State push-soft
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.push-soft ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again);
}
else
{
transition-to-state(push-soft);
}
## State put-right
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.put-right ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-right);
}
else
{
transition-to-state(put-right);
}
## State put-left
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.put-left ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-left);
}
else
{
transition-to-state(put-left);
}
## State slap-right
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.slap-right ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-right);
}
else
{
transition-to-state(slap-right);
}
## State slap-left
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.slap-left ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-left);
}
else
{
transition-to-state(slap-left);
}
## State hook-right
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.hook-right ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-right);
}
else
{
transition-to-state(hook-right);
}
## State hook-left
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.hook-left ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-left);
}
else
{
transition-to-state(hook-left);
}
## State forward-kick-fast
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.forward-kick-fast ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again);
}
else
{
transition-to-state(forward-kick-fast);
}
## State forward-kick-hard
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.forward-kick-hard ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again);
}
else
{
transition-to-state(forward-kick-hard);
}
## State head-left-soft
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.head-left-soft ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-left);
}
else
{
transition-to-state(head-left-soft);
}
## State head-right-soft
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.head-right-soft ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-right);
}
else
{
transition-to-state(head-right-soft);
}
## State back-kick-left
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.back-kick-left ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-left);
}
else
{
transition-to-state(back-kick-left);
}
## State back-kick-right
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.back-kick-right ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-right);
}
else
{
transition-to-state(back-kick-right);
}
## State kick-along-arm-left
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.kick-along-arm-left ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-left);
}
else
{
transition-to-state(kick-along-arm-left);
}
## State kick-along-arm-right
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.kick-along-arm-right ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-right);
}
else
{
transition-to-state(kick-along-arm-right);
}
## State kick-with-back-leg-left
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.kick-with-back-leg-left ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-left);
}
else
{
transition-to-state(kick-with-back-leg-left);
}
## State kick-with-back-leg-right
If that state is active,
> | The option do-kick is executed. Parameters:
| do-kick.special-action-id | = | special-action.kick-with-back-leg-right ;
The decision tree:
Pseudo code of the decision tree:
if ( | subsequent-option-reached-target-state | ) | // Kick finished
{
transition-to-state(find-ball-again-right);
}
else
{
transition-to-state(kick-with-back-leg-right);
}
## State find-ball-again
If that state is active,
> | The basic behavior walk is executed. Parameters:
| walk.type | = | walk-type.normal ;
| walk.speed-x | = | 50 ;
| walk.speed-y | = | 0 ;
| walk.rotation-speed | = | 0 ;
> | These output symbols are set:
| head-control-mode | = | head-control-mode.search-for-ball
The decision tree:
Pseudo code of the decision tree:
if ( | ball.just-seen | ) | // ball seen again
{
transition-to-state(finished);
}
else if ( | time-of-state-execution < 1000 | ) | // state running less than 1 second
{
transition-to-state(find-ball-again);
}
else
{
transition-to-state(finished);
}
## State find-ball-again-left
If that state is active,
> | The basic behavior stand is executed.
> | These output symbols are set:
| head-control-mode | = | head-control-mode.search-for-ball-left
The decision tree:
Pseudo code of the decision tree:
if ( | ball.just-seen | ) | // ball seen again
{
transition-to-state(finished);
}
else if ( | time-of-state-execution < 1000 | ) | // state running less than 1 second
{
transition-to-state(find-ball-again-left);
}
else
{
transition-to-state(finished);
}
## State find-ball-again-right
If that state is active,
> | The basic behavior stand is executed.
> | These output symbols are set:
| head-control-mode | = | head-control-mode.search-for-ball-right
The decision tree:
Pseudo code of the decision tree:
if ( | ball.just-seen | ) | // ball seen again
{
transition-to-state(finished);
}
else if ( | time-of-state-execution < 1000 | ) | // state running less than 1 second
{
transition-to-state(find-ball-again-right);
}
else
{
transition-to-state(finished);
}
## State finished
This state is a target state.
If that state is active,
> | The basic behavior stand is executed.
> | These output symbols are set:
| head-control-mode | = | head-control-mode.search-for-ball
| strategy.set-time-kick | = | strategy.set-time-kick.save-time
The decision tree:
Pseudo code of the decision tree:
transition-to-state(finished);