>xabsl 2
Behavior Documentation


>Index
>Agents
>Symbols
>Basic Behaviors
>Options
   >>  other-head-movement
        >>>  hold-ball
        >>>  open-challenge
        >>>  none
        >>>  look-left
        >>>  look-right
        >>>  scan-for-obstacles
        >>>  search-for-landmarks
        >>>  search-for-landmarks-head-low
        >>>  look-at-blue-pink-landmark
        >>>  look-straight-ahead
        >>>  look-toward-opponent-goal
        >>>  look-between-feet
        >>>  look-to-stars
        >>>  snap-at-finger
        >>>  look-parallel-to-ground
        >>>  direct
        >>>  stay-as-forced
        >>>  watch-origin
        >>>  calibrate-head-speed

Option other-head-movement

Selects between ball tracking and other movements

State Machine

This browser can't display the SVG file svg/option_other-head-movement.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html

State hold-ball

If that state is active,
 >  The basic behavior hold-ball is executed.
 
The decision tree:
  This browser can't display the SVG file svg/option_other-head-movement_state_hold-ball.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_open-challenge.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_none.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_look-left.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_look-right.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_scan-for-obstacles.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_search-for-landmarks.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_search-for-landmarks-head-low.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_look-at-blue-pink-landmark.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_look-straight-ahead.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_look-toward-opponent-goal.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_look-between-feet.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_look-to-stars.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_snap-at-finger.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_look-parallel-to-ground.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_direct.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_stay-as-forced.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_watch-origin.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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:
  This browser can't display the SVG file svg/option_other-head-movement_state_calibrate-head-speed.svg.



The Adobe SVG Viewer 3.0 can be downloaded from http://www.adobe.com/svg/viewer/install/main.html
 
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);
}