# Option other-head-movement Selects between ball tracking and other movements ## State Machine ## State hold-ball
If that state is active,
> | The basic behavior hold-ball is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(hold-ball);
}

## State open-challenge

If that state is active,
> | The basic behavior open-challenge is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(open-challenge);
}

## State none

If that state is active,
> | The basic behavior none is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(none);
}

## State look-left

If that state is active,
> | The basic behavior look-left is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(look-left);
}

## State look-right

If that state is active,
> | The basic behavior look-right is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(look-right);
}

## State scan-for-obstacles

If that state is active,
> | The basic behavior scan-for-obstacles is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(scan-for-obstacles);
}

## State search-for-landmarks

If that state is active,
> | The basic behavior search-for-landmarks is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(search-for-landmarks);
}

## State search-for-landmarks-head-low

If that state is active,
> | The basic behavior search-for-landmarks-head-low is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(search-for-landmarks-head-low);
}

## State look-at-blue-pink-landmark

If that state is active,
> | The basic behavior look-at-blue-pink-landmark is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(look-at-blue-pink-landmark);
}

## State look-straight-ahead

If that state is active,
> | The basic behavior look-straight-ahead is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(look-straight-ahead);
}

## State look-toward-opponent-goal

If that state is active,
> | The basic behavior look-toward-opponent-goal is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(look-toward-opponent-goal);
}

## State look-between-feet

If that state is active,
> | The basic behavior look-between-feet is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(look-between-feet);
}

## State look-to-stars

If that state is active,
> | The basic behavior look-to-stars is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(look-to-stars);
}

## State snap-at-finger

If that state is active,
> | The basic behavior snap-at-finger is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(snap-at-finger);
}

## State look-parallel-to-ground

If that state is active,
> | The basic behavior look-parallel-to-ground is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(look-parallel-to-ground);
}

## State direct

If that state is active,
> | The basic behavior direct is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(direct);
}

## State stay-as-forced

If that state is active,
> | The basic behavior stay-as-forced is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(stay-as-forced);
}

## State watch-origin

If that state is active,
> | The basic behavior watch-origin is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(watch-origin);
}

## State calibrate-head-speed

If that state is active,
> | The basic behavior calibrate-head-speed is executed.
The decision tree:
Pseudo code of the decision tree:
if ( | head-control-mode == hold-ball | ) | // blablbabla
{
transition-to-state(hold-ball);
}
else if ( | head-control-mode == none | ) | // blablbabla
{
transition-to-state(none);
}
else if ( | head-control-mode == look-left | ) | // blablbabla
{
transition-to-state(look-left);
}
else if ( | head-control-mode == look-right | ) | // blablbabla
{
transition-to-state(look-right);
}
else if ( | head-control-mode == scan-for-obstacles | ) | // blablbabla
{
transition-to-state(scan-for-obstacles);
}
else if ( | head-control-mode == search-for-landmarks | ) | // blablbabla
{
transition-to-state(search-for-landmarks);
}
else if ( | head-control-mode == search-for-landmarks-head-low | ) | // blablbabla
{
transition-to-state(search-for-landmarks-head-low);
}
else if ( | head-control-mode == look-at-blue-pink-landmark | ) | // blablbabla
{
transition-to-state(look-at-blue-pink-landmark);
}
else if ( | head-control-mode == look-straight-ahead | ) | // blablbabla
{
transition-to-state(look-straight-ahead);
}
else if ( | head-control-mode == look-toward-opponent-goal | ) | // blablbabla
{
transition-to-state(look-toward-opponent-goal);
}
else if ( | head-control-mode == look-between-feet | ) | // blablbabla
{
transition-to-state(look-between-feet);
}
else if ( | head-control-mode == look-to-stars | ) | // blablbabla
{
transition-to-state(look-to-stars);
}
else if ( | head-control-mode == snap-at-finger | ) | // blablbabla
{
transition-to-state(snap-at-finger);
}
else if ( | head-control-mode == look-parallel-to-ground | ) | // blablbabla
{
transition-to-state(look-parallel-to-ground);
}
else if ( | head-control-mode == direct | ) | // blablbabla
{
transition-to-state(direct);
}
else if ( | head-control-mode == stay-as-forced | ) | // blablbabla
{
transition-to-state(stay-as-forced);
}
else if ( | head-control-mode == watch-origin | ) | // blablbabla
{
transition-to-state(watch-origin);
}
else if ( | head-control-mode == calibrate-head-speed | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == real-slow-scan | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( | head-control-mode == look-between-feet-for-carried-ball | ) | // blablbabla
{
transition-to-state(calibrate-head-speed);
}
else if ( |
!( | head-control-mode == direct | )
| ) | // DUMMY, because just else did not kompile here
{
transition-to-state(open-challenge);
}
else
{
transition-to-state(calibrate-head-speed);
}