program test {
  sensor s1 on 1
  sensor s2 on 2
  event left when s1.pressed
  event right when s2.pressed
  main {
    start feelers
  }
  watcher feelers monitor left, right { sound 3 }
}


program test {
  sensor s1 on 1
  sensor s2 on 2
  event left when s1.pressed
  event right when s2.pressed
  main {
    start feelers
  }
  watcher feelers monitor left, right {
    if left {sound 3} else {sound 4}
  }
}


program test {
  output A on 1
  output B on 2
  sensor s1 on 1
  sensor s2 on 2
  event left when s1.pressed
  event right when s2.pressed
  main {
    start feelers
  }
  watcher feelers monitor left, right {
    priority 3
    if left { try { on A wait 100 off A } retry on fail }
    if right { try { on B wait 100 off B } retry on fail }
  } restart on event
}


program test {
  output A on 1
  output B on 2
  output C on 3
  main {
    priority 7
    try {sound 3 on [A B C] wait 10} retry on fail
  }
}


program test {
  output A on 1
  output B on 2
  output C on 3
  main {
    priority 7
    try {
      sound 3
      try {on [A B C]} abort on fail  //illegal nesting
    } retry on fail
  }
}


program testPriority {
  output A on 1
  const low_priority = 7
  const high_priority = 1
  sensor s1 on 1
  event left when s1.pressed
  main {
    start leftWatcher
    priority low_priority
    forever {
      try {on A for 200} abort on fail
      wait 50
    }
  }
  watcher leftWatcher monitor left { 
    priority high_priority
    try {off A} retry on fail
  }
}


program abortOnEventTest {
  sensor s1 on 1
  event left when s1.pressed
  main {
    monitor left {
      forever {sound 1 wait 10}
    } abort on event
  }
}


program counterTest {
  output A on 1
  counter c
  event beep when c = 3
  main {
    clear c
    start beeper
    repeat 6 {c += 1 on A for 100 wait 100}
  }
  watcher beeper monitor beep {sound 3 clear c}
}


program inlineTest {
  macro beep {repeat 2 {wait 50 sound 2}}
  macro bop {repeat 2 {wait 20 sound 1}}
  macro buzz {tone 50 for 100}
  macro ping {tone 100 for 10}
  main {
    beep wait 100 
    bop wait 50 
    buzz wait 100 
    ping
  }
}


program macroTest {
  var w = 50
  macro beep {
    repeat 5 {wait w sound 1}
  }
  main {
    beep
  }
}


program macroTest {
  macro beep(nTimes) {
    repeat nTimes {wait 50 sound 1}
  }
  main {
    beep(5)
  }
}


program macroTest {
  macro beep(nTimes) {
    repeat nTimes {wait 50 sound 1}
  }
  main {
    local n = 5
    beep(n)
  }
}


program macroTest {
  macro beep(nTimes, nTone) {
    repeat nTimes {
      wait 50 tone nTone for 20 
      nTone += 110  //illegal operation on const parameter
    }
  }
  main {
    beep(5,220)
  }
}


program macroTest {
  macro beep {
    local n = 5
    while n > 0 {sound 1 wait 50 n -= 1}
  }
  main {beep}
}


program macroTest {
  macro beep {
    local n = 5
    while n > 0 {sound 1 wait 50 n -= 1}
  }
  main {beep wait 100 start test}
  task test {beep}
}


program macroTest {
  macro beep(nTimes) {
    local n = nTimes
    while n > 0 {sound 1 wait 50 n -= 1}
  }
  main {beep(5) wait 100 start test}
  task test {beep(3)}
}


program macroTest {
  var w = 50
  var n = 2
  macro beep {
    repeat 5 {wait w sound 1}
  }
  main {
    repeat n {beep wait w}
  }
}


program inlineTest {
  macro beep(n) {repeat n {wait 50 sound 2}}
  macro bop(m,n) {repeat m {wait n sound 3}}
  macro buzz(x) {tone x for 100}
  macro ping(y) {tone y for 50}
  macro pong(a,b) {repeat a {tone b for 20 wait 20}}
  main {
    beep(2) wait 100 
    bop(3,100) wait 100 
    buzz(100) wait 150 
    ping(440) wait 200
    pong(6,800) wait 250
  }
}


program inlineTest {
  macro beep {repeat 2 {wait 50 sound 1}}
  macro bop {repeat 2 {wait 20 sound 2}}
  macro buzz {tone 50 for 100}
  macro ping(y) {tone y for 10}
  main {
    beep wait 100 
    bop wait 50 
    buzz wait 100 
    ping(440)
  }
}


program globalTest {
  output A on 1
  output B on 2
  sensor s1 on 1
  sensor s2 on 2
  event left when s1.pressed
  event right when s2.pressed
  main {
    global power [A B] 4
    power [A B] 7
    global reverse [A B]
    start leftFeeler
    start rightFeeler
  }
  watcher leftFeeler monitor left {fd [A B] on [A B] for 50}
  watcher rightFeeler monitor right {bk [A B] on [A B] for 50}
}


program testTone {
  main {
    local v = 5
    tone 10 * v for 50
  }
}


program sensorTest {
  sensor opto on 3
  opto is light as percent  //RCX2 only, Scout light sensor is raw (0-1020)
  main {
    forever {
      if opto < 60 {sound 2 wait 20}
    }
  }
}


program sensorTest {
  sensor opto on 3
  opto is light as percent
  event bright when opto.high
  main {
    forever {
      if bright.state = 2 {sound 2 wait 50}
    }
  }
}


program testMacro {
  macro doit {
    tone 200 for 50
  }
  main {
    doit
  }
}


program testMacro {
  macro doit(x) {
    tone x for 50
  }
  main {
    doit(200)
  }
}


program testMacro {
  macro doit(x,y) {
    tone x for 50
    wait y
  }
  main {
    doit(200,100)
    doit(200,1)
  }
}


program testVars {
  var y = 440  //ok - global initialisation (in main)
  main {tone y for 50}
}

program testVars {
  local y  //invalid local declaration
  main {y = 440 tone y for 50}
}

program testVars {
  main {
    var y  //invalid global declaration
    y = 440
    tone y for 50
  }
}

program testVars {
  main {
    local y
    y = 440  //ok - y is local
    tone y for 50
  }
}

program testVars {
  var y  //ok - y is global
  main {
    y = 440  //ok - ok uses global y
    tone y for 50
  }
}


program testVars {
  sensor s1 on 1
  sensor s2 on 2
  event left when s1.pressed
  event right when s2.pressed
  var y = 100  //global var 9
  macro ping(y) {
    tone y for 10
  }
  main {
    local y = 220  //task local var 16
    tone y for 100
    start beep start bop
    ping(660)
    ping(y)
  }
  watcher beep monitor left {
    local y = 440  //task local var 15
    tone y for 50
  }
  watcher bop monitor right {
    local y = 880  //task local var 15
    tone y for 50
  }
}


program macroTest {
  var y
  macro beep {tone y for 50}
  main {y = 220 beep}
}

program macroTest {
  var y
  macro beep {local y = 220 tone y for 50}
  main {y = 440 beep}
}

program macroTest {
  macro beep(y) {tone y for 50}
  main {beep(440)}
}

program macroTest {
  macro beep(y) {tone y for 50}
  main {local y = 440 beep(y)}
}

program macroTest {
  var y
  macro beep(y) {tone y for 50}
  main {y = 440 beep(y)}
}

program macroTest {
  var y
  macro beep(y) {y += 10 tone y for 50}
  main {y = 440 beep(y)}
}

program macroParamTest {
  macro beep(n) {repeat n {wait 50 sound 1}}
  macro bop(m,n) {repeat m {wait n sound 2}}
  main {beep(2) wait 100 bop(3,100)}
}


program declareTest {
  var a = 10
  var b = 100 + a
  main {
    tone a*b for 50
  }
}


program declareTest {
  main {
    local a = 10
    local b = 100 + a
    tone a*b for 50
  }
}


program test {
  sensor left on 1
  main {
    if left is opened {sound 3}
  }
}


program testNesting {
  output A on 1
  output B on 2
  var x = 20
  var y = 42
  main {
    if x > 10 {
      sound 3
      if y > 20 {tone 400 for 50} else {sound 5}
      sound 4
    }
    else {
      on [A B] for 100
    }
  }
}


program waitUntilTest {
  sensor left on 1
  event e when left.pressed
  main {
    wait until e
    sound 3
  }
}


program repeatUntilTest {
  sensor left on 1
  event e when left.pressed
  main {
    repeat {sound 1 wait 100} until e
    sound 3
  }
}


program repeatUntilTest {
  sensor left on 1
  sensor right on 2
  event e when left.pressed
  event touch when right.pressed
  main {
    start beeper
  }
  watcher beeper monitor touch {
    sound 2
    repeat {sound 1 wait 100} until e
    sound 3
  }
}


program repeatUntilTest {
  sensor left on 1
  sensor right on 2
  event e when left.pressed
  event touch when right.pressed
  main {
    start beeper
  }
  watcher beeper monitor touch {
    sound 2
    repeat {wait 100 sound 1} until e
    sound 3
    repeat {wait 100 sound 1} until e
    sound 4
  } restart on event
}


program sensorStateTest {
  sensor opto on 3
  opto is light as percent
  event e when opto.high
  main {
    //over-ride auto-calibration
    e.high = 60
    e.low = 40
    e.hysteresis = 2
    display e.state
    while e.state = 1 {sound 1 wait 100}
    sound 3
  }
}


program sensorConditionTest {
  sensor s1 on 1
  sensor s2 on 2
  event left when s1.pressed
  event right when s2.pressed
  main {
    if s1 = closed {sound 2}  //sensor state
    start touch
  }
  watcher touch monitor left {
    if left {sound 3 wait 100}  //event
    if right {sound 4 wait 100}  //will never be true - not monitored!
    if s2 = closed {sound 5}  //sensor state
  }
}


program repeatTest {
  main {
    repeat 2 {
      repeat 2 {
        repeat 2 {
          repeat 2 {wait 50 sound 1}
        }
      }
    }
  }
}


program repeatTest {
  main {
    local v = 5
    repeat 2 {
      repeat 2 {
        repeat 2 {
          repeat 2 {v += 5 wait v sound 1}
        }
      }
    }
  }
}


program test {
  main {
    local v = 100
    repeat 5 {tone v for 50 v += 250 wait 50}
  }
}


program hitTest {
  sensor s1 on 1
  sensor s2 on 2
  event left when s1.pressed
  event right when s2.pressed
  var dummy = 0
  var hits = 0
  main { start feelers }
  watcher feelers monitor left, right { hits += 1 sound 3 }
}

get hits  //execute with symbol table context from hitTest compilation


program emptyTryTest {
  output A on 1
  output B on 2
  sensor s1 on 1
  event left when s1.pressed
  main {
    start x
    try { } retry on fail
  }
  watcher x monitor left { 
    try {on [A B]} retry on fail
  }
}


program testTask {
  main { 
    start Beep
  }
  task Beep {
    forever { sound 1 wait 100 }
  }
}


program testSensors {
  sensor s1 on 1
  left is switch as boolean
  event left when s1.pressed
  main { 
    start beeper
  }
  watcher beeper monitor left {sound 1}
}


program testSelect {
  sensor s1 on 1
  event left when s1.pressed
  var count = 0
  main { start bumper }
  watcher bumper monitor left {
    count += 1
    select count {
      when 1 {sound 1}
      when 2 {sound 2}
      when 3 {sound 3}
      else {clear count sound 4}
    }
  }
}


program testSelect {
  sensor s1 on 1
  event left when s1.pressed
  main { start bumper }
  watcher bumper monitor left {
    select random 4 {
      when 0 {sound 1}
      when 1 {sound 2}
      when 2 {sound 3}
      when 3 {sound 4}
    }
  }
}


program testSelect {
  output A on 1
  event post when message
  main {start MessageTask}
  watcher MessageTask monitor post {
    local msg = message
    clear message
    select msg {
      when 1 {on A for 10 sound 5}
      when 2 {sound 2}
      when 3 {sound 3}
      else {sound 10}
    }
  }
}


program eventTest {
  sensor s1 on 1
  left is switch as boolean
  event left when s1.pressed
  main {
    start bumper
  }
  watcher bumper monitor left {sound 1}
}


program testRCX2Sub {
  output A on 1
  output B on 2
  macro ZigZag(nSteps, nTime) {
    repeat nSteps {
      on A for nTime
      on B for nTime
    }
  }
  main { 
    ZigZag(5,50) 
  }
}


program testRCX2Sub {
  output A on 1
  output B on 2
  var v = 4
  macro ZigZag(nSteps, nTime) {
    repeat nSteps {
      on A for nTime
      on B for nTime
    }
  }
  main { 
    ZigZag(v,50) 
  }
}


program macroRepeatLoop {
  macro Test {
    repeat 4 {wait 100}
  }
  main {
    local n = 42
    Test
    if n = 42 {sound 3}
  }
}


program testOutputProperties {
  output A on 1
  sensor s1 on 1
  event left when s1.pressed
  main { start feelers power A 1 on A}
  watcher feelers monitor left {
    local p = A.status
    p &= 7  //mask power bits only
    if p = 7 {sound 3 off A} else {p += 1 power A p}
  }
}


program testOutputProperties {
  output A on 1
  sensor s1 on 1
  event left when s1.pressed
  main { start feelers power A 1 on A}
  watcher feelers monitor left {
    local p = A.power  //1..8
    if p = 8 {sound 3 off A} else {p += 1 power A p}
  }
}


program testOutputProperties {
  output A on 1
  sensor s1 on 1
  event left when s1.pressed
  var ap
  var step = 1
  main {
    power A 1  // 1-8
    on A 
    display ap  // 0-7
    start bumper
    forever { ap = A.power }
  }
  watcher bumper monitor left {
    local p = A.power  // 0-7
    if p = 7 { step = -1 }
    if p = 0 { step = 1 }
    p += step
    power A p
  }
}


program testOutputProperties {
  output A on 1
  output C on 3
  main {
    power A 1
    power C 8
    power C A.power
    on [A C] for 10
  }
}


program SeekLight {
  const nTime = 25
  const nSteps = 10
  sensor opto on 3
  output A on 1
  output B on 2
  main {
    local loopCount
    local seekDetect
    local oldLight
    local newLight

    off [A B]
    forward A
    backward B
    sound 2
    wait 60

    seekDetect = 0
    oldLight = opto.raw
    loopCount = nSteps
    on [A B]
    repeat 2 {
      while loopCount > 0 {
        sound 1
        wait nTime
        newLight = opto.raw
        if seekDetect < 0x00ff {
          if newLight > oldLight {
            oldLight = newLight
            seekDetect = loopCount
          }
        }
        loopCount -= 1
      }

      off [A B]
      wait 60
      if seekDetect < nSteps {
        forward B
        backward A
        loopCount = seekDetect
        seekDetect |= 0x0100
        on [A B]
      }
      else
      {
        loopCount = 0
        sound 3
        wait 60
      }
    }
  }
}


program test {
  sensor s1 on 1
  sensor s2 on 2
  event left when s1.pressed
  event right when s2.pressed
  main { start feeler }
  watcher feeler monitor left {
    sound 1
    monitor right {wait 100 sound 3} abort on event
  }
}


program test {
  sensor s1 on 1
  sensor s2 on 2
  event left when s1.pressed
  event right when s2.pressed
  main { start feeler }
  watcher feeler monitor left {
    sound 1
    monitor right {wait 100 sound 3} restart on event
  }
}


program testRCX2 {
  sensor opto on 1
  opto is light as percent
  var v
  main {
    forever {
      v = 1020
      v -= opto.raw
      if v > 510 {sound 3} else {sound 4}
    }
   }
}


program testSubResults {
  sensor opto on 1
  opto is light as percent
  macro GetAverageLight(opto,nAverage) {
    local sample
    nAverage = opto.raw
    repeat 4 {
      wait 3 
      sample = opto.raw
      nAverage += sample
    }
    nAverage /= 5
  }
  var average
  main {
    local nAverage
    display average
    forever {
      GetAverageLight(opto,nAverage)
      average = nAverage
    }
  }
}


program test {
  sensor axle on 2
  axle is rotation as angle
  main {
    clear axle
    display axle
  }
}


program test {
  #include <RCX2.h>

  macro bb_Forward(nLeftOutput, nRightOutput, nDuration) {
    forward [nLeftOutput nRightOutput]
    power [nLeftOutput nRightOutput] 7
    on [nLeftOutput nRightOutput] for nDuration
  }

  main { 
    bb_Forward(A,C,50)
  }
}


program testParamExpression {
  macro beep(nTime) { 
    sound 3
    wait nTime
  }
  main { 
    local v = 5
    beep(v+3)
  }
}


program testPortParams {
  macro OnFor(Outputs, nDuration) { on Outputs for nDuration}
  output A on 1
  output C on 3
  main { 
    OnFor([A C], 50)
  }
}


program testPortParams {
  macro bb_Forward(nLeft, nRight, nTime) {
    dir [nLeft nRight] [ ]
    on [nLeft nRight] for nTime
  }
  output A on 1
  output B on 2
  main {
    bb_Forward(A,B,50)
  }
}


program testPortParams {
  #include <RCX2.h>

  macro sb_SetDirection(ForwardOutputs, BackwardOutputs) { 
    forward ForwardOutputs
    backward BackwardOutputs
  }

  macro sb_SetPower(Outputs, nPower) {power Outputs nPower}

  macro sb_OnFor(Outputs, nDuration) {on Outputs for nDuration}

  macro bb_Forward(Outputs, nDuration) {
    sb_SetDirection(Outputs, [])
    sb_SetPower(Outputs, 7)
    sb_OnFor(Outputs, nDuration)
  }

  main { 
    bb_Forward([A C],50)
  }
}


program testRandom {
  var v
  main {
    v = random 1 to 6
    repeat v {wait 100 sound 2}
  }
}


program globalTest {
  output A on 1
  output B on 2
  sensor s1 on 1
  sensor s2 on 2
  event left when s1.pressed
  event right when s2.pressed
  main {
    global power [A B] 4
    power [A B] 8
    global dir A B
    start leftFeeler
    start rightFeeler
  }
  watcher leftFeeler monitor left {fd [A B] on [A B] for 50}
  watcher rightFeeler monitor right {bk [A B] on [A B] for 50}
}


program testMacroTry {
  macro Beep(nWait) {sound 3 wait nWait}
  main {
    try {Beep(50)} retry on fail
  }
}


program testMacroTry {
  macro bb_Forward(nLeft, nRight, nTime) {
    dir [nLeft nRight] [ ]
    on [nLeft nRight] for nTime
  }
  output A on 1
  output B on 2
  main {
    try {bb_Forward(A,B,50)} retry on fail
  }
}


program test {
  output A on 1
  var p
  main {
    forever {
      power A random 0 to 7
      p = A.power
      display p
      wait 100
    }
  }
}


program test {
  main { repeat random 0 to 2 { wait 100 sound 2 } }
}


program switchEventTest {
  sensor s1 on 1
  event left when s1.pressed
  main {start feeler}
  watcher feeler monitor left {sound 3}
}


program switchEventTest {
  sensor s1 on 1
  sensor s2 on 2
  event left when s1.pressed
  event right when s2.pressed
  main {start feelers}
  watcher feelers monitor left, right {
    if left {sound 1} else {sound 3}
  }
}


program soundTest {
  macro scale {
    tone 262 for 1
    tone 294 for 1
    tone 330 for 1
    tone 350 for 1
    tone 392 for 1
    tone 440 for 1
    tone 494 for 1
    tone 523 for 1
    tone 587 for 1
    tone 660 for 1
    wait 10
    tone 699 for 1
    tone 785 for 1
    tone 880 for 1
    tone 988 for 1
    tone 1047 for 1
    wait 5
  }
  main {
    forever {wait random 5 to 50 scale}
  }
}


program eventSoundTest {
  #include <RCX2.h>
  #include <RCX2Sounds.h>
  sensor s1 on 1
  sensor s2 on 2
  event leftPressed when s1.pressed
  event leftReleased when s1.released
  event rightPressed when s2.pressed
  event rightReleased when s2.released

  main {
    start leftSwitch
    start rightSwitch
  }

  watcher leftSwitch monitor leftPressed, leftReleased {
    clear sound
    try {if leftPressed {sound_11} else {sound_12}} abort on fail
  } restart on event

  watcher rightSwitch monitor rightPressed, rightReleased {
    clear sound
    try {if rightPressed {sound_13} else {sound_14}} abort on fail
  } restart on event
}


program localTest {  //RCX2
  main {
    local a47 = 47
    local a46 = 46
    local a45 = 45
    local a44 = 44
    local a43 = 43
    local a42 = 42
    local a41 = 41
    local a40 = 40
    local a39 = 39
    local a38 = 38
    local a37 = 37
    local a36 = 36
    local a35 = 35
    local a34 = 34
    local a33 = 33
//    local a32 = 32
    tone a47 * 50 for 50
  }
}


program watchTest {
  main {
    local t
    forever {
      t = watch  //RCX2 watch
      if t > 10 {sound 3}
    }
  }
}


program eventSoundTest {
  #include <RCX2.h>
  #include <RCX2Sounds.h>

  sensor s1 on 1
  sensor s2 on 2

  event leftPressed when s1.pressed
  event leftReleased when s1.released
  event rightPressed when s2.pressed
  event rightReleased when s2.released

  var nEventSound

  main {
    start EventSounds
  }

  watcher EventSounds monitor leftPressed,leftReleased,rightPressed,rightReleased {
    if leftPressed {nEventSound = 11 start PlaySound}
    if leftReleased {nEventSound = 12 start PlaySound}
    if rightPressed {nEventSound = 13 start PlaySound}
    if rightReleased {nEventSound = 14 start PlaySound}
  } restart on event

  task PlaySound {
    clear sound
    select nEventSound {
      when 11 {sound_11}
      when 12 {sound_12}
      when 13 {sound_13}
      when 14 {sound_14}
    }
  }
}


program soundTest {
//Scout & RCX2 compatible - select headers
  #include <RCX2.h>
  #include <RCX2Sounds.h>
//
//  #include <Scout.h>
//  #include <ScoutSounds.h>
  sensor s1 on 1
  sensor s2 on 2
  s1 is switch as boolean
  s2 is switch as boolean
  event left when s1.pressed
  event right when s2.pressed
  event post when message
  var nEventSound

  main {
    nEventSound = 7
    start bumpers
    start postbox
  }

  watcher bumpers monitor left, right {
    if left
    {
      nEventSound += 1
      if nEventSound > 28 {nEventSound = 7}
    }
    else  //right
    {
      send nEventSound
      wait 10
    }
    clear sound
    start PlaySound
  }

  watcher postbox monitor post {
    nEventSound = message
    clear message
    clear sound
    start PlaySound
  }

  task PlaySound {
    select nEventSound {
      when 7 {sound_7}
      when 8 {sound_8}
      when 9 {sound_9}
      when 10 {sound_10}
      when 11 {sound_11}
      when 12 {sound_12}
      when 13 {sound_13}
      when 14 {sound_14}
      when 15 {sound_15}
      when 16 {sound_16}
      when 17 {sound_17}
      when 18 {sound_18}
      when 19 {sound_19}
      when 20 {sound_20}
      when 21 {sound_21}
      when 22 {sound_22}
      when 23 {sound_23}
      when 24 {sound_24}
      when 25 {sound_25}
      when 26 {sound_26}
      when 27 {sound_27}
      when 28 {sound_28}
    }
  }
}


program testVLL {
  #include <RCX2.h>
  #include <RCX2VLL.h>
  main {
    on C wait 40
    forever {
      wait 250
      ms_Beep1(C)
      wait 250
      ms_Beep2(C)
      wait 250
      ms_Beep3(C)
      wait 250
      ms_Beep4(C)
      wait 250
      ms_Beep5(C)
    }
  }
}


program testVLL {
  #include <RCX2.h>
  #include <RCX2VLL.h>
  main {
    on C wait 40
    ms_Delete_Script(C)
    ms_Script_Beep1(C)
    ms_Script_Beep2(C)
    ms_Script_Beep3(C)
    ms_Script_Beep4(C)
    ms_Script_Beep5(C)
    ms_Run_Script(C)
  }
}


program testVLL {
  #include <RCX2.h>
  #include <RCX2VLL.h>
  main {
    on C wait 40
    ms_Delete_Script(C)
    ms_Script_Fwd05(C)
    ms_Script_Rwd05(C)
    ms_Script_Fwd10(C)
    ms_Script_Rwd10(C)
    ms_Script_Fwd20(C)
    ms_Script_Rwd20(C)
    ms_Script_Fwd50(C)
    ms_Script_Rwd50(C)
    ms_Run_Script(C)
  }
}


program testRCX2VLL {
  #include <RCX2.h>
  #include <RCX2VLL.h>
  main {
    on [A C] wait 40
    start ScoutBeeper
    start ScoutDriver
  }
  task ScoutDriver {
    forever {
      ms_Fwd(C)
      wait 100
      ms_Rwd(C)
      wait 100
    }
  }
  task ScoutBeeper {
    forever {
      ms_Beep1(A)
      wait 200
      ms_Beep2(A)
      wait 200
      ms_Beep3(A)
      wait 200
      ms_Beep4(A)
      wait 200
      ms_Beep5(A)
      wait 200
    }
  }
}


program tryout {
  task 9 {
    repeat 6 {tone random 50 to 200 for 10}
  }
}


program test {
  #include <RCX2.h>
  var n
  main {
    forever {
      n =  random 0 to 7
      display n
      power [A B C] n
      on [A B C] for (random 1 to 10)*10
      wait 100
    }
  }
}


program test {
  #include <RCX2.h>
  const f1 = 440
  const f2 = 880
  const t = 5
  main {
    forever {
      tone random f1 to f2 for t*10
      wait t*10
    }
  }
}


program test{
  var v = -42 
  main {
    v = abs(v) * -1
    display v
    forever {}
  }
}


program test {
  main {
    clear message
    while message = 0 { }
    while message = 10 {
      sound 2
      clear message
      wait 500
    }
    sound 3
  }
}


program test {
  sensor s1 on 1
  sensor s2 on 2
  event left when s1.pressed
  event right when s2.pressed
  main {
    start feelers
  }
  watcher feelers monitor left, right { sound 3 }
  fragment(100,250) {sound 3}
}


program testMessage {
  #include <RCX2.h>
  event beep when message
  main {
    clear message
    start beeper
    forever {send 1 wait 50}
  }
  watcher beeper monitor beep {
    clear message
    sound 1
  }
}


program testBlink {
  #include <RCX2.h>
  sensor eye on 3
  eye is light as percent
  event beep when eye.click
  main {
    beep.time = 50
    start beeper
    forever {on C for 10 wait 50}
  }
  watcher beeper monitor beep {
    sound 1
  }
}


program testDoubleBlink {
  #include <RCX2.h>
  sensor eye on 3
  eye is light as percent
  event beep when eye.doubleclick
  macro myDoubleBlink {on C for 10 wait 10 on C for 10}
  main {
    beep.time = 100
    start beeper
    forever {myDoubleBlink wait 50}
  }
  watcher beeper monitor beep {
    sound 1
  }
}


program testDoubleBlink {
  #include <RCX2.h>
  sensor eye on 3
  eye is light as percent
  event beep when eye.doubleclick
  macro myDoubleBlink {on C for 10 wait 10 on C for 10}
  main {
    priority 8
    beep.time = 100
    start beeper
    forever
    {
      try {myDoubleBlink wait 200} retry on fail
    }
  }
  watcher beeper monitor beep {
    priority 3
    try {sound 1 myDoubleBlink} abort on fail
  }
}


program test {
  #include <RCX2.h>
  const t = 100
  var f
  main {
    randomize
    display f
    forever {
      f = 10*random 50 to 80
      tone f for t wait t}
  }
}


program test {
  output A on 1
  output B on 2
  output C on 3
  const t1 = 1
  const t2 = 3276
  var v
  main {
    v = random t1 to t2
    display v:1
    on [A B C] for v * 10
    forever {}
  }
}


program test {
  const t1 = 1
  const t2 = 6
  var v
  main {
    wait 100
    v = (random t1 to t2) * 10
    display v:1
    repeat v / 10 {sound 1 wait 50}
    forever {}
  }
}


program test {
  var v
  var v1
  var v2
  main {
    v = 50
    v1 = 10
    v2 = 20
    wait 100
    while v is v1/10..v2/10 {sound 1 v -= 1 wait 100}
  }
}


program test {
  sensor s on 1
  s is light as percent
  const c1 = 20
  const c2 = 60
  var v1
  var v2
  main {
    v1 = 200
    v2 = 600
    wait 100
    while s*10 is c1*10..v2 {sound 1 wait 100}
  }
}


program test {
  output A on 1
  output C on 3
  main {
    forever {
      if random 2 > 1 {
        on A for 50
      } else {
        on C for 50
      }
    }
  }
}


program testCounter {
  output A on 1
  counter myCounter = 0
  sensor s on 1
  s is switch as boolean
  event bump when s.pressed
  event hits when myCounter > 4

  main {
    priority 8
    start bumper
    start hitter

    display myCounter
  }

  watcher bumper monitor bump {
    priority 2
    try {
      myCounter += 1
      on A for 10
    } stop on fail
  } restart on event

  watcher hitter monitor hits {
    priority 6
    try {
      clear myCounter
      on A for 10
    } stop on fail
  } restart on event
}


program testProgramSlotSwitching {
  sensor s1 on 1
  s1 is switch as boolean
  event left when s1.pressed
  main {
    start bumper
  }
  watcher bumper monitor left { sound 2  slot 2 }
}


program testSubLocals {
  macro test { repeat 2 { sound 1 wait 50 } }
  main {start t1}
  task t1 {
    local v = 10
    test
    if v = 10 {sound 3}
    test  //as a macro, uses same temp as v!
  }
}


program test {
  sensor s on 1
  s is switch as boolean
  event e when s.pressed
  main {
    while s is closed { tone 400 for 10 wait 20 }  //beep while closed
    while e.state = 1 { sound 1 wait 20 }  //beep while opened
  }
}


program test {
  var v1 = 5
  var v2 = 3
  main {
    if v1 + 1 > v2 + 1 {sound 3}
  }
}


program test {
  var v1 = 5
  var v2 = 3
  main {
    while v1 + 1 > v2 + 1 {sound 3 wait 100 v1 -= 1}
  }
}
