home *** CD-ROM | disk | FTP | other *** search
/ Joystick Magazine 2002 December / JOY143_CD1.iso / Data / Demos / Platoon / pl_demo.exe / Inf / Gamelogic / GameEvents / uSub.Fight.inf < prev    next >
INI File  |  2002-10-14  |  32KB  |  2,000 lines
  1.  
  2. [uSub.Fight : cESEvent]
  3. {
  4.     Name = uSub.Fight
  5.     Enabled = 1
  6.     Type = 2
  7.     RefreshRate = 0
  8.  
  9.     [Procedures *]
  10.     {
  11.  
  12.         [: cESSubrutine]
  13.         {
  14.             Subrutine = uSub.SetWeapon
  15.  
  16.         }
  17.         [: cUStoreCmdTarget]
  18.         {
  19.             VarName = DebugTarget
  20.             LocalVar = 0
  21.  
  22.             [Target : cUGetSquadLastKnownTargetPos]
  23.             {
  24.  
  25.             }
  26.         }
  27.         [: cESSwitch]
  28.         {
  29.             Note = ""
  30.  
  31.             [Value : cUGetCommandState]
  32.             {
  33.  
  34.             }
  35.             [Case *]
  36.             {
  37.  
  38.                 [: cESCase]
  39.                 {
  40.                     Note = "0 - Start, stop, select"
  41.                     Value = 0
  42.  
  43.                     [Procedures *]
  44.                     {
  45.  
  46.                         [: cESIf]
  47.                         {
  48.                             Note = "HasShotInLastFrame torlese"
  49.  
  50.                             [Condition : cUHasShotInLastFrame]
  51.                             {
  52.                                 Note = ""
  53.  
  54.                             }
  55.                             [Then *]
  56.                             {
  57.  
  58.                             }
  59.                             [Else *]
  60.                             {
  61.  
  62.                             }
  63.                         }
  64.                         [: cESIntToVar]
  65.                         {
  66.                             VariableName = TimeBeforeShooting
  67.                             Keep = 1
  68.  
  69.                             [Value : cESFIntConstRnd]
  70.                             {
  71.                                 Value = 0
  72.  
  73.                                 [Valure2 : cESGetGlobalParameter]
  74.                                 {
  75.                                     ParamName = time_rnd_before_shooting
  76.  
  77.                                 }
  78.                             }
  79.                         }
  80.                         [: cUAttackTargetSelection]
  81.                         {
  82.  
  83.                             [Target : cUGetCommandTarget]
  84.                             {
  85.  
  86.                             }
  87.                         }
  88.                         [: cESIf]
  89.                         {
  90.                             Note = ""
  91.  
  92.                             [Condition : cMIsEmptyTarget]
  93.                             {
  94.                                 Note = ""
  95.  
  96.                                 [Target : cUGetAttackTarget]
  97.                                 {
  98.  
  99.                                 }
  100.                             }
  101.                             [Then *]
  102.                             {
  103.  
  104.                                 [: cESLog]
  105.                                 {
  106.                                     Text = "AttackTarget is empty"
  107.  
  108.                                 }
  109.                                 [: cESIf]
  110.                                 {
  111.                                     Note = "StopBeforeFireCommand == TRUE?"
  112.  
  113.                                     [Condition : cESCNumEquals]
  114.                                     {
  115.                                         Note = ""
  116.  
  117.                                         [Value1 : cESFIntFromMember]
  118.                                         {
  119.                                             VariableName = StopBeforeFireCommand
  120.  
  121.                                             [Object : cSGetByThisUnit]
  122.                                             {
  123.  
  124.                                             }
  125.                                         }
  126.                                         [Value2 : cESFIntConst]
  127.                                         {
  128.                                             Value = 1
  129.  
  130.                                         }
  131.                                     }
  132.                                     [Then *]
  133.                                     {
  134.  
  135.                                         [: cUStop]
  136.                                         {
  137.  
  138.                                             [Entity : cGetThisUnit]
  139.                                             {
  140.  
  141.                                             }
  142.                                         }
  143.                                     }
  144.                                     [Else *]
  145.                                     {
  146.  
  147.                                     }
  148.                                 }
  149.                                 [: cUCommandCompleted]
  150.                                 {
  151.  
  152.                                 }
  153.                             }
  154.                             [Else *]
  155.                             {
  156.  
  157.                                 [: cESSubrutine]
  158.                                 {
  159.                                     Subrutine = uSub.GetTargetCondition
  160.  
  161.                                 }
  162.                                 [: cESIf]
  163.                                 {
  164.                                     Note = ""
  165.  
  166.                                     [Condition : cESCNumEquals]
  167.                                     {
  168.                                         Note = ""
  169.  
  170.                                         [Value1 : cESFIntByVar]
  171.                                         {
  172.                                             VariableName = TargetCondition
  173.  
  174.                                         }
  175.                                         [Value2 : cESFIntConst]
  176.                                         {
  177.                                             Value = 0
  178.  
  179.                                         }
  180.                                     }
  181.                                     [Then *]
  182.                                     {
  183.  
  184.                                         [: cESLog]
  185.                                         {
  186.                                             Text = "AttackTarget is empty"
  187.  
  188.                                         }
  189.                                         [: cESIf]
  190.                                         {
  191.                                             Note = "StopBeforeFireCommand == TRUE?"
  192.  
  193.                                             [Condition : cESCNumEquals]
  194.                                             {
  195.                                                 Note = ""
  196.  
  197.                                                 [Value1 : cESFIntFromMember]
  198.                                                 {
  199.                                                     VariableName = StopBeforeFireCommand
  200.  
  201.                                                     [Object : cSGetByThisUnit]
  202.                                                     {
  203.  
  204.                                                     }
  205.                                                 }
  206.                                                 [Value2 : cESFIntConst]
  207.                                                 {
  208.                                                     Value = 1
  209.  
  210.                                                 }
  211.                                             }
  212.                                             [Then *]
  213.                                             {
  214.  
  215.                                                 [: cUStop]
  216.                                                 {
  217.  
  218.                                                     [Entity : cGetThisUnit]
  219.                                                     {
  220.  
  221.                                                     }
  222.                                                 }
  223.                                             }
  224.                                             [Else *]
  225.                                             {
  226.  
  227.                                             }
  228.                                         }
  229.                                         [: cUCommandCompleted]
  230.                                         {
  231.  
  232.                                         }
  233.                                     }
  234.                                     [Else *]
  235.                                     {
  236.  
  237.                                         [: cUSetCommandSubState]
  238.                                         {
  239.  
  240.                                             [State : cESFIntConst]
  241.                                             {
  242.                                                 Value = 0
  243.  
  244.                                             }
  245.                                         }
  246.                                         [: cESSwitch]
  247.                                         {
  248.                                             Note = "Switch on TargetCondition"
  249.  
  250.                                             [Value : cESFIntByVar]
  251.                                             {
  252.                                                 VariableName = TargetCondition
  253.  
  254.                                             }
  255.                                             [Case *]
  256.                                             {
  257.  
  258.                                                 [: cESCase]
  259.                                                 {
  260.                                                     Note = "1 - Approach"
  261.                                                     Value = 1
  262.  
  263.                                                     [Procedures *]
  264.                                                     {
  265.  
  266.                                                         [: cUSetCommandState]
  267.                                                         {
  268.  
  269.                                                             [State : cESFIntConst]
  270.                                                             {
  271.                                                                 Value = 1
  272.  
  273.                                                             }
  274.                                                         }
  275.                                                     }
  276.                                                 }
  277.                                                 [: cESCase]
  278.                                                 {
  279.                                                     Note = "2 - GetInPosition (too close)"
  280.                                                     Value = 2
  281.  
  282.                                                     [Procedures *]
  283.                                                     {
  284.  
  285.                                                         [: cUSetCommandState]
  286.                                                         {
  287.  
  288.                                                             [State : cESFIntConst]
  289.                                                             {
  290.                                                                 Value = 0
  291.  
  292.                                                             }
  293.                                                         }
  294.                                                     }
  295.                                                 }
  296.                                                 [: cESCase]
  297.                                                 {
  298.                                                     Note = "3 - TurnTo"
  299.                                                     Value = 3
  300.  
  301.                                                     [Procedures *]
  302.                                                     {
  303.  
  304.                                                         [: cUSetCommandState]
  305.                                                         {
  306.  
  307.                                                             [State : cESFIntConst]
  308.                                                             {
  309.                                                                 Value = 2
  310.  
  311.                                                             }
  312.                                                         }
  313.                                                     }
  314.                                                 }
  315.                                                 [: cESCase]
  316.                                                 {
  317.                                                     Note = "4 - GetInPosition (in ideal shoot position)"
  318.                                                     Value = 4
  319.  
  320.                                                     [Procedures *]
  321.                                                     {
  322.  
  323.                                                         [: cUSetCommandState]
  324.                                                         {
  325.  
  326.                                                             [State : cESFIntConst]
  327.                                                             {
  328.                                                                 Value = 3
  329.  
  330.                                                             }
  331.                                                         }
  332.                                                     }
  333.                                                 }
  334.                                                 [: cESCase]
  335.                                                 {
  336.                                                     Note = "5 - Approach and fire"
  337.                                                     Value = 5
  338.  
  339.                                                     [Procedures *]
  340.                                                     {
  341.  
  342.                                                         [: cUSetCommandState]
  343.                                                         {
  344.  
  345.                                                             [State : cESFIntConst]
  346.                                                             {
  347.                                                                 Value = 1
  348.  
  349.                                                             }
  350.                                                         }
  351.                                                     }
  352.                                                 }
  353.                                                 [: cESCase]
  354.                                                 {
  355.                                                     Note = "6"
  356.                                                     Value = 6
  357.  
  358.                                                     [Procedures *]
  359.                                                     {
  360.  
  361.                                                         [: cUSetCommandState]
  362.                                                         {
  363.  
  364.                                                             [State : cESFIntConst]
  365.                                                             {
  366.                                                                 Value = 5
  367.  
  368.                                                             }
  369.                                                         }
  370.                                                     }
  371.                                                 }
  372.                                             }
  373.                                         }
  374.                                     }
  375.                                 }
  376.                             }
  377.                         }
  378.                     }
  379.                 }
  380.                 [: cESCase]
  381.                 {
  382.                     Note = "1 - Start approaching"
  383.                     Value = 1
  384.  
  385.                     [Procedures *]
  386.                     {
  387.  
  388.                         [: cESSubrutine]
  389.                         {
  390.                             Subrutine = uSub.GetTargetCondition
  391.  
  392.                         }
  393.                         [: cESSwitch]
  394.                         {
  395.                             Note = "Switch on TargetCondition"
  396.  
  397.                             [Value : cESFIntByVar]
  398.                             {
  399.                                 VariableName = TargetCondition
  400.  
  401.                             }
  402.                             [Case *]
  403.                             {
  404.  
  405.                                 [: cESCase]
  406.                                 {
  407.                                     Note = "0 - Start, stop, select"
  408.                                     Value = 0
  409.  
  410.                                     [Procedures *]
  411.                                     {
  412.  
  413.                                         [: cUSetCommandState]
  414.                                         {
  415.  
  416.                                             [State : cESFIntConst]
  417.                                             {
  418.                                                 Value = 0
  419.  
  420.                                             }
  421.                                         }
  422.                                     }
  423.                                 }
  424.                                 [: cESCase]
  425.                                 {
  426.                                     Note = "1 - Approach"
  427.                                     Value = 1
  428.  
  429.                                     [Procedures *]
  430.                                     {
  431.  
  432.                                         [: cESSubrutine]
  433.                                         {
  434.                                             Subrutine = uSub.SMS_Assault
  435.  
  436.                                         }
  437.                                         [: cESIf]
  438.                                         {
  439.                                             Note = "Ha kesz"
  440.  
  441.                                             [Condition : cESCNumEquals]
  442.                                             {
  443.                                                 Note = ""
  444.  
  445.                                                 [Value1 : cUGetCommandSubState]
  446.                                                 {
  447.  
  448.                                                 }
  449.                                                 [Value2 : cESFIntConst]
  450.                                                 {
  451.                                                     Value = -1
  452.  
  453.                                                 }
  454.                                             }
  455.                                             [Then *]
  456.                                             {
  457.  
  458.                                                 [: cUSetCommandSubState]
  459.                                                 {
  460.  
  461.                                                     [State : cESFIntConst]
  462.                                                     {
  463.                                                         Value = 0
  464.  
  465.                                                     }
  466.                                                 }
  467.                                                 [: cUSetMoveTarget]
  468.                                                 {
  469.                                                     Translate = 0
  470.  
  471.                                                     [Target : cUGetSquadLastKnownTargetPos]
  472.                                                     {
  473.  
  474.                                                     }
  475.                                                 }
  476.                                                 [: cUSetCommandState]
  477.                                                 {
  478.  
  479.                                                     [State : cESFIntConst]
  480.                                                     {
  481.                                                         Value = 11
  482.  
  483.                                                     }
  484.                                                 }
  485.                                             }
  486.                                             [Else *]
  487.                                             {
  488.  
  489.                                             }
  490.                                         }
  491.                                     }
  492.                                 }
  493.                                 [: cESCase]
  494.                                 {
  495.                                     Note = "2 - GetInPosition (too close)"
  496.                                     Value = 2
  497.  
  498.                                     [Procedures *]
  499.                                     {
  500.  
  501.                                         [: cUSetCommandSubState]
  502.                                         {
  503.  
  504.                                             [State : cESFIntConst]
  505.                                             {
  506.                                                 Value = 0
  507.  
  508.                                             }
  509.                                         }
  510.                                         [: cUSetCommandState]
  511.                                         {
  512.  
  513.                                             [State : cESFIntConst]
  514.                                             {
  515.                                                 Value = 0
  516.  
  517.                                             }
  518.                                         }
  519.                                     }
  520.                                 }
  521.                                 [: cESCase]
  522.                                 {
  523.                                     Note = "3 - TurnTo"
  524.                                     Value = 3
  525.  
  526.                                     [Procedures *]
  527.                                     {
  528.  
  529.                                         [: cUSetCommandSubState]
  530.                                         {
  531.  
  532.                                             [State : cESFIntConst]
  533.                                             {
  534.                                                 Value = 0
  535.  
  536.                                             }
  537.                                         }
  538.                                         [: cUSetCommandState]
  539.                                         {
  540.  
  541.                                             [State : cESFIntConst]
  542.                                             {
  543.                                                 Value = 2
  544.  
  545.                                             }
  546.                                         }
  547.                                     }
  548.                                 }
  549.                                 [: cESCase]
  550.                                 {
  551.                                     Note = "4 - GetInPosition (in ideal shoot position) (identical to no. 2)"
  552.                                     Value = 4
  553.  
  554.                                     [Procedures *]
  555.                                     {
  556.  
  557.                                         [: cUSetCommandSubState]
  558.                                         {
  559.  
  560.                                             [State : cESFIntConst]
  561.                                             {
  562.                                                 Value = 0
  563.  
  564.                                             }
  565.                                         }
  566.                                         [: cUSetCommandState]
  567.                                         {
  568.  
  569.                                             [State : cESFIntConst]
  570.                                             {
  571.                                                 Value = 3
  572.  
  573.                                             }
  574.                                         }
  575.                                     }
  576.                                 }
  577.                                 [: cESCase]
  578.                                 {
  579.                                     Note = "5 - Approach and fire (identical to no. 1)"
  580.                                     Value = 5
  581.  
  582.                                     [Procedures *]
  583.                                     {
  584.  
  585.                                         [: cESSubrutine]
  586.                                         {
  587.                                             Subrutine = uSub.SMS_Assault
  588.  
  589.                                         }
  590.                                         [: cESIf]
  591.                                         {
  592.                                             Note = "Ha kesz"
  593.  
  594.                                             [Condition : cESCNumEquals]
  595.                                             {
  596.                                                 Note = ""
  597.  
  598.                                                 [Value1 : cUGetCommandSubState]
  599.                                                 {
  600.  
  601.                                                 }
  602.                                                 [Value2 : cESFIntConst]
  603.                                                 {
  604.                                                     Value = -1
  605.  
  606.                                                 }
  607.                                             }
  608.                                             [Then *]
  609.                                             {
  610.  
  611.                                                 [: cUSetCommandSubState]
  612.                                                 {
  613.  
  614.                                                     [State : cESFIntConst]
  615.                                                     {
  616.                                                         Value = 0
  617.  
  618.                                                     }
  619.                                                 }
  620.                                                 [: cUSetMoveTarget]
  621.                                                 {
  622.                                                     Translate = 0
  623.  
  624.                                                     [Target : cUGetAttackTarget]
  625.                                                     {
  626.  
  627.                                                     }
  628.                                                 }
  629.                                                 [: cUSetCommandState]
  630.                                                 {
  631.  
  632.                                                     [State : cESFIntConst]
  633.                                                     {
  634.                                                         Value = 11
  635.  
  636.                                                     }
  637.                                                 }
  638.                                             }
  639.                                             [Else *]
  640.                                             {
  641.  
  642.                                             }
  643.                                         }
  644.                                     }
  645.                                 }
  646.                                 [: cESCase]
  647.                                 {
  648.                                     Note = "6"
  649.                                     Value = 6
  650.  
  651.                                     [Procedures *]
  652.                                     {
  653.  
  654.                                         [: cUSetCommandState]
  655.                                         {
  656.  
  657.                                             [State : cESFIntConst]
  658.                                             {
  659.                                                 Value = 5
  660.  
  661.                                             }
  662.                                         }
  663.                                     }
  664.                                 }
  665.                             }
  666.                         }
  667.                     }
  668.                 }
  669.                 [: cESCase]
  670.                 {
  671.                     Note = "11 - Wait for getting in position"
  672.                     Value = 11
  673.  
  674.                     [Procedures *]
  675.                     {
  676.  
  677.                         [: cESSubrutine]
  678.                         {
  679.                             Subrutine = uSub.GetTargetCondition
  680.  
  681.                         }
  682.                         [: cESSwitch]
  683.                         {
  684.                             Note = "Switch on TargetCodition"
  685.  
  686.                             [Value : cESFIntByVar]
  687.                             {
  688.                                 VariableName = TargetCondition
  689.  
  690.                             }
  691.                             [Case *]
  692.                             {
  693.  
  694.                                 [: cESCase]
  695.                                 {
  696.                                     Note = "0 - Start, stop, select"
  697.                                     Value = 0
  698.  
  699.                                     [Procedures *]
  700.                                     {
  701.  
  702.                                         [: cUSetCommandState]
  703.                                         {
  704.  
  705.                                             [State : cESFIntConst]
  706.                                             {
  707.                                                 Value = 0
  708.  
  709.                                             }
  710.                                         }
  711.                                     }
  712.                                 }
  713.                                 [: cESCase]
  714.                                 {
  715.                                     Note = "1 - Set up the movement style again if neccessary"
  716.                                     Value = 1
  717.  
  718.                                     [Procedures *]
  719.                                     {
  720.  
  721.                                         [: cESSubrutine]
  722.                                         {
  723.                                             Subrutine = uSub.SMS_Assault
  724.  
  725.                                         }
  726.                                     }
  727.                                 }
  728.                                 [: cESCase]
  729.                                 {
  730.                                     Note = "2 - GetInPosition (too close)"
  731.                                     Value = 2
  732.  
  733.                                     [Procedures *]
  734.                                     {
  735.  
  736.                                         [: cUSetCommandSubState]
  737.                                         {
  738.  
  739.                                             [State : cESFIntConst]
  740.                                             {
  741.                                                 Value = 0
  742.  
  743.                                             }
  744.                                         }
  745.                                         [: cUSetCommandState]
  746.                                         {
  747.  
  748.                                             [State : cESFIntConst]
  749.                                             {
  750.                                                 Value = 0
  751.  
  752.                                             }
  753.                                         }
  754.                                     }
  755.                                 }
  756.                                 [: cESCase]
  757.                                 {
  758.                                     Note = "3 - TurnTo"
  759.                                     Value = 3
  760.  
  761.                                     [Procedures *]
  762.                                     {
  763.  
  764.                                         [: cUSetCommandSubState]
  765.                                         {
  766.  
  767.                                             [State : cESFIntConst]
  768.                                             {
  769.                                                 Value = 0
  770.  
  771.                                             }
  772.                                         }
  773.                                         [: cUSetCommandState]
  774.                                         {
  775.  
  776.                                             [State : cESFIntConst]
  777.                                             {
  778.                                                 Value = 2
  779.  
  780.                                             }
  781.                                         }
  782.                                     }
  783.                                 }
  784.                                 [: cESCase]
  785.                                 {
  786.                                     Note = "4 - GetInPosition (in ideal shoot position)"
  787.                                     Value = 4
  788.  
  789.                                     [Procedures *]
  790.                                     {
  791.  
  792.                                         [: cUSetCommandSubState]
  793.                                         {
  794.  
  795.                                             [State : cESFIntConst]
  796.                                             {
  797.                                                 Value = 0
  798.  
  799.                                             }
  800.                                         }
  801.                                         [: cUSetCommandState]
  802.                                         {
  803.  
  804.                                             [State : cESFIntConst]
  805.                                             {
  806.                                                 Value = 3
  807.  
  808.                                             }
  809.                                         }
  810.                                     }
  811.                                 }
  812.                                 [: cESCase]
  813.                                 {
  814.                                     Note = "5 - Approach and fire"
  815.                                     Value = 5
  816.  
  817.                                     [Procedures *]
  818.                                     {
  819.  
  820.                                         [: cUFire]
  821.                                         {
  822.  
  823.                                         }
  824.                                     }
  825.                                 }
  826.                                 [: cESCase]
  827.                                 {
  828.                                     Note = "6 - Stop"
  829.                                     Value = 6
  830.  
  831.                                     [Procedures *]
  832.                                     {
  833.  
  834.                                         [: cUSetCommandState]
  835.                                         {
  836.  
  837.                                             [State : cESFIntConst]
  838.                                             {
  839.                                                 Value = 5
  840.  
  841.                                             }
  842.                                         }
  843.                                     }
  844.                                 }
  845.                             }
  846.                         }
  847.                     }
  848.                 }
  849.                 [: cESCase]
  850.                 {
  851.                     Note = "2 - Stop approaching, turn"
  852.                     Value = 2
  853.  
  854.                     [Procedures *]
  855.                     {
  856.  
  857.                         [: cESIf]
  858.                         {
  859.                             Note = "If it is permitted to stop"
  860.  
  861.                             [Condition : cESCNumEquals]
  862.                             {
  863.                                 Note = ""
  864.  
  865.                                 [Value1 : cESFIntFromMember]
  866.                                 {
  867.                                     VariableName = StopBeforeFireCommand
  868.  
  869.                                     [Object : cSGetByThisUnit]
  870.                                     {
  871.  
  872.                                     }
  873.                                 }
  874.                                 [Value2 : cESFIntConst]
  875.                                 {
  876.                                     Value = 1
  877.  
  878.                                 }
  879.                             }
  880.                             [Then *]
  881.                             {
  882.  
  883.                                 [: cUStop]
  884.                                 {
  885.  
  886.                                     [Entity : cGetThisUnit]
  887.                                     {
  888.  
  889.                                     }
  890.                                 }
  891.                             }
  892.                             [Else *]
  893.                             {
  894.  
  895.                             }
  896.                         }
  897.                         [: cESSubrutine]
  898.                         {
  899.                             Subrutine = uSub.GetTargetCondition
  900.  
  901.                         }
  902.                         [: cESSwitch]
  903.                         {
  904.                             Note = "Switch on TargetCondition"
  905.  
  906.                             [Value : cESFIntByVar]
  907.                             {
  908.                                 VariableName = TargetCondition
  909.  
  910.                             }
  911.                             [Case *]
  912.                             {
  913.  
  914.                                 [: cESCase]
  915.                                 {
  916.                                     Note = "0 - Start, stop, select"
  917.                                     Value = 0
  918.  
  919.                                     [Procedures *]
  920.                                     {
  921.  
  922.                                         [: cUSetCommandState]
  923.                                         {
  924.  
  925.                                             [State : cESFIntConst]
  926.                                             {
  927.                                                 Value = 0
  928.  
  929.                                             }
  930.                                         }
  931.                                     }
  932.                                 }
  933.                                 [: cESCase]
  934.                                 {
  935.                                     Note = "2 - GetInPosition (too close)"
  936.                                     Value = 2
  937.  
  938.                                     [Procedures *]
  939.                                     {
  940.  
  941.                                         [: cUSetCommandSubState]
  942.                                         {
  943.  
  944.                                             [State : cESFIntConst]
  945.                                             {
  946.                                                 Value = 0
  947.  
  948.                                             }
  949.                                         }
  950.                                         [: cUSetCommandState]
  951.                                         {
  952.  
  953.                                             [State : cESFIntConst]
  954.                                             {
  955.                                                 Value = 3
  956.  
  957.                                             }
  958.                                         }
  959.                                     }
  960.                                 }
  961.                                 [: cESCase]
  962.                                 {
  963.                                     Note = "3 - TurnTo"
  964.                                     Value = 3
  965.  
  966.                                     [Procedures *]
  967.                                     {
  968.  
  969.                                         [: cESSubrutine]
  970.                                         {
  971.                                             Subrutine = uSub.SMS_Turn
  972.  
  973.                                         }
  974.                                         [: cESIf]
  975.                                         {
  976.                                             Note = Befejezte?
  977.  
  978.                                             [Condition : cESCNumEquals]
  979.                                             {
  980.                                                 Note = ""
  981.  
  982.                                                 [Value1 : cUGetCommandSubState]
  983.                                                 {
  984.  
  985.                                                 }
  986.                                                 [Value2 : cESFIntConst]
  987.                                                 {
  988.                                                     Value = -1
  989.  
  990.                                                 }
  991.                                             }
  992.                                             [Then *]
  993.                                             {
  994.  
  995.                                                 [: cESSubrutine]
  996.                                                 {
  997.                                                     Subrutine = uSub.AimBeforeShooting
  998.  
  999.                                                 }
  1000.                                                 [: cUTurnTo]
  1001.                                                 {
  1002.  
  1003.                                                     [Target : cUGetAttackTarget]
  1004.                                                     {
  1005.  
  1006.                                                     }
  1007.                                                     [TurnToTarget : NULL]
  1008.                                                     {
  1009.  
  1010.                                                     }
  1011.                                                 }
  1012.                                                 [: cUSetCommandSubState]
  1013.                                                 {
  1014.  
  1015.                                                     [State : cESFIntConst]
  1016.                                                     {
  1017.                                                         Value = 0
  1018.  
  1019.                                                     }
  1020.                                                 }
  1021.                                                 [: cUSetCommandState]
  1022.                                                 {
  1023.  
  1024.                                                     [State : cESFIntConst]
  1025.                                                     {
  1026.                                                         Value = 22
  1027.  
  1028.                                                     }
  1029.                                                 }
  1030.                                             }
  1031.                                             [Else *]
  1032.                                             {
  1033.  
  1034.                                             }
  1035.                                         }
  1036.                                     }
  1037.                                 }
  1038.                                 [: cESCase]
  1039.                                 {
  1040.                                     Note = "4 - GetInPosition (in ideal shoot position) "
  1041.                                     Value = 4
  1042.  
  1043.                                     [Procedures *]
  1044.                                     {
  1045.  
  1046.                                         [: cUSetCommandSubState]
  1047.                                         {
  1048.  
  1049.                                             [State : cESFIntConst]
  1050.                                             {
  1051.                                                 Value = 0
  1052.  
  1053.                                             }
  1054.                                         }
  1055.                                         [: cUSetCommandState]
  1056.                                         {
  1057.  
  1058.                                             [State : cESFIntConst]
  1059.                                             {
  1060.                                                 Value = 22
  1061.  
  1062.                                             }
  1063.                                         }
  1064.                                     }
  1065.                                 }
  1066.                                 [: cESCase]
  1067.                                 {
  1068.                                     Note = "1 - tul messze"
  1069.                                     Value = 1
  1070.  
  1071.                                     [Procedures *]
  1072.                                     {
  1073.  
  1074.                                         [: cUSetCommandState]
  1075.                                         {
  1076.  
  1077.                                             [State : cESFIntConst]
  1078.                                             {
  1079.                                                 Value = 0
  1080.  
  1081.                                             }
  1082.                                         }
  1083.                                     }
  1084.                                 }
  1085.                                 [: cESCase]
  1086.                                 {
  1087.                                     Note = "6 - Stop"
  1088.                                     Value = 6
  1089.  
  1090.                                     [Procedures *]
  1091.                                     {
  1092.  
  1093.                                         [: cUSetCommandState]
  1094.                                         {
  1095.  
  1096.                                             [State : cESFIntConst]
  1097.                                             {
  1098.                                                 Value = 5
  1099.  
  1100.                                             }
  1101.                                         }
  1102.                                     }
  1103.                                 }
  1104.                             }
  1105.                         }
  1106.                     }
  1107.                 }
  1108.                 [: cESCase]
  1109.                 {
  1110.                     Note = "22 - Wait for turning"
  1111.                     Value = 22
  1112.  
  1113.                     [Procedures *]
  1114.                     {
  1115.  
  1116.                         [: cESSubrutine]
  1117.                         {
  1118.                             Subrutine = uSub.AimBeforeShooting
  1119.  
  1120.                         }
  1121.                         [: cESIf]
  1122.                         {
  1123.                             Note = ""
  1124.  
  1125.                             [Condition : cUIsTurnCompleted]
  1126.                             {
  1127.                                 Note = ""
  1128.  
  1129.                             }
  1130.                             [Then *]
  1131.                             {
  1132.  
  1133.                                 [: cUSetCommandSubState]
  1134.                                 {
  1135.  
  1136.                                     [State : cESFIntConst]
  1137.                                     {
  1138.                                         Value = 0
  1139.  
  1140.                                     }
  1141.                                 }
  1142.                                 [: cUSetCommandState]
  1143.                                 {
  1144.  
  1145.                                     [State : cESFIntConst]
  1146.                                     {
  1147.                                         Value = 3
  1148.  
  1149.                                     }
  1150.                                 }
  1151.                             }
  1152.                             [Else *]
  1153.                             {
  1154.  
  1155.                                 [: cESSubrutine]
  1156.                                 {
  1157.                                     Subrutine = uSub.GetTargetCondition
  1158.  
  1159.                                 }
  1160.                                 [: cESSwitch]
  1161.                                 {
  1162.                                     Note = "Switch on TargetCondition"
  1163.  
  1164.                                     [Value : cESFIntByVar]
  1165.                                     {
  1166.                                         VariableName = TargetCondition
  1167.  
  1168.                                     }
  1169.                                     [Case *]
  1170.                                     {
  1171.  
  1172.                                         [: cESCase]
  1173.                                         {
  1174.                                             Note = "0 - Start, stop, select"
  1175.                                             Value = 0
  1176.  
  1177.                                             [Procedures *]
  1178.                                             {
  1179.  
  1180.                                                 [: cUSetCommandState]
  1181.                                                 {
  1182.  
  1183.                                                     [State : cESFIntConst]
  1184.                                                     {
  1185.                                                         Value = 0
  1186.  
  1187.                                                     }
  1188.                                                 }
  1189.                                             }
  1190.                                         }
  1191.                                         [: cESCase]
  1192.                                         {
  1193.                                             Note = "1 - tul messze"
  1194.                                             Value = 1
  1195.  
  1196.                                             [Procedures *]
  1197.                                             {
  1198.  
  1199.                                                 [: cUSetCommandSubState]
  1200.                                                 {
  1201.  
  1202.                                                     [State : cESFIntConst]
  1203.                                                     {
  1204.                                                         Value = 0
  1205.  
  1206.                                                     }
  1207.                                                 }
  1208.                                                 [: cUSetCommandState]
  1209.                                                 {
  1210.  
  1211.                                                     [State : cESFIntConst]
  1212.                                                     {
  1213.                                                         Value = 0
  1214.  
  1215.                                                     }
  1216.                                                 }
  1217.                                             }
  1218.                                         }
  1219.                                         [: cESCase]
  1220.                                         {
  1221.                                             Note = "2 - GetInPosition (too close)"
  1222.                                             Value = 2
  1223.  
  1224.                                             [Procedures *]
  1225.                                             {
  1226.  
  1227.                                                 [: cUSetCommandSubState]
  1228.                                                 {
  1229.  
  1230.                                                     [State : cESFIntConst]
  1231.                                                     {
  1232.                                                         Value = 0
  1233.  
  1234.                                                     }
  1235.                                                 }
  1236.                                                 [: cUSetCommandState]
  1237.                                                 {
  1238.  
  1239.                                                     [State : cESFIntConst]
  1240.                                                     {
  1241.                                                         Value = 0
  1242.  
  1243.                                                     }
  1244.                                                 }
  1245.                                             }
  1246.                                         }
  1247.                                         [: cESCase]
  1248.                                         {
  1249.                                             Note = "4 - GetInPosition (in ideal shoot position) "
  1250.                                             Value = 4
  1251.  
  1252.                                             [Procedures *]
  1253.                                             {
  1254.  
  1255.                                             }
  1256.                                         }
  1257.                                         [: cESCase]
  1258.                                         {
  1259.                                             Note = "5 - Fire and run"
  1260.                                             Value = 5
  1261.  
  1262.                                             [Procedures *]
  1263.                                             {
  1264.  
  1265.                                                 [: cUSetCommandState]
  1266.                                                 {
  1267.  
  1268.                                                     [State : cESFIntConst]
  1269.                                                     {
  1270.                                                         Value = 0
  1271.  
  1272.                                                     }
  1273.                                                 }
  1274.                                             }
  1275.                                         }
  1276.                                         [: cESCase]
  1277.                                         {
  1278.                                             Note = "6 - Stop"
  1279.                                             Value = 6
  1280.  
  1281.                                             [Procedures *]
  1282.                                             {
  1283.  
  1284.                                                 [: cUSetCommandState]
  1285.                                                 {
  1286.  
  1287.                                                     [State : cESFIntConst]
  1288.                                                     {
  1289.                                                         Value = 5
  1290.  
  1291.                                                     }
  1292.                                                 }
  1293.                                             }
  1294.                                         }
  1295.                                     }
  1296.                                 }
  1297.                             }
  1298.                         }
  1299.                     }
  1300.                 }
  1301.                 [: cESCase]
  1302.                 {
  1303.                     Note = "3 - Stop approaching, get in position"
  1304.                     Value = 3
  1305.  
  1306.                     [Procedures *]
  1307.                     {
  1308.  
  1309.                         [: cESIf]
  1310.                         {
  1311.                             Note = "If it is permitted to stop"
  1312.  
  1313.                             [Condition : cESCNumEquals]
  1314.                             {
  1315.                                 Note = ""
  1316.  
  1317.                                 [Value1 : cESFIntFromMember]
  1318.                                 {
  1319.                                     VariableName = StopBeforeFireCommand
  1320.  
  1321.                                     [Object : cSGetByThisUnit]
  1322.                                     {
  1323.  
  1324.                                     }
  1325.                                 }
  1326.                                 [Value2 : cESFIntConst]
  1327.                                 {
  1328.                                     Value = 1
  1329.  
  1330.                                 }
  1331.                             }
  1332.                             [Then *]
  1333.                             {
  1334.  
  1335.                                 [: cUStop]
  1336.                                 {
  1337.  
  1338.                                     [Entity : cGetThisUnit]
  1339.                                     {
  1340.  
  1341.                                     }
  1342.                                 }
  1343.                             }
  1344.                             [Else *]
  1345.                             {
  1346.  
  1347.                             }
  1348.                         }
  1349.                         [: cESSubrutine]
  1350.                         {
  1351.                             Subrutine = uSub.GetTargetCondition
  1352.  
  1353.                         }
  1354.                         [: cESSwitch]
  1355.                         {
  1356.                             Note = "Switch on TargetCondition"
  1357.  
  1358.                             [Value : cESFIntByVar]
  1359.                             {
  1360.                                 VariableName = TargetCondition
  1361.  
  1362.                             }
  1363.                             [Case *]
  1364.                             {
  1365.  
  1366.                                 [: cESCase]
  1367.                                 {
  1368.                                     Note = "0 - Start, stop, select"
  1369.                                     Value = 0
  1370.  
  1371.                                     [Procedures *]
  1372.                                     {
  1373.  
  1374.                                         [: cUSetCommandState]
  1375.                                         {
  1376.  
  1377.                                             [State : cESFIntConst]
  1378.                                             {
  1379.                                                 Value = 0
  1380.  
  1381.                                             }
  1382.                                         }
  1383.                                     }
  1384.                                 }
  1385.                                 [: cESCase]
  1386.                                 {
  1387.                                     Note = "1 - Tul messze"
  1388.                                     Value = 1
  1389.  
  1390.                                     [Procedures *]
  1391.                                     {
  1392.  
  1393.                                         [: cUSetCommandState]
  1394.                                         {
  1395.  
  1396.                                             [State : cESFIntConst]
  1397.                                             {
  1398.                                                 Value = 0
  1399.  
  1400.                                             }
  1401.                                         }
  1402.                                     }
  1403.                                 }
  1404.                                 [: cESCase]
  1405.                                 {
  1406.                                     Note = "2 - Stop approaching, turn"
  1407.                                     Value = 2
  1408.  
  1409.                                     [Procedures *]
  1410.                                     {
  1411.  
  1412.                                         [: cUSetCommandState]
  1413.                                         {
  1414.  
  1415.                                             [State : cESFIntConst]
  1416.                                             {
  1417.                                                 Value = 0
  1418.  
  1419.                                             }
  1420.                                         }
  1421.                                     }
  1422.                                 }
  1423.                                 [: cESCase]
  1424.                                 {
  1425.                                     Note = "3 - stop approaching, get in position"
  1426.                                     Value = 3
  1427.  
  1428.                                     [Procedures *]
  1429.                                     {
  1430.  
  1431.                                         [: cUSetCommandState]
  1432.                                         {
  1433.  
  1434.                                             [State : cESFIntConst]
  1435.                                             {
  1436.                                                 Value = 0
  1437.  
  1438.                                             }
  1439.                                         }
  1440.                                     }
  1441.                                 }
  1442.                                 [: cESCase]
  1443.                                 {
  1444.                                     Note = "4 - Wait and shoot"
  1445.                                     Value = 4
  1446.  
  1447.                                     [Procedures *]
  1448.                                     {
  1449.  
  1450.                                         [: cESSubrutine]
  1451.                                         {
  1452.                                             Subrutine = uSub.SMS_FireHoldingPosition
  1453.  
  1454.                                         }
  1455.                                         [: cESIf]
  1456.                                         {
  1457.                                             Note = "If finished..."
  1458.  
  1459.                                             [Condition : cESCNumEquals]
  1460.                                             {
  1461.                                                 Note = ""
  1462.  
  1463.                                                 [Value1 : cUGetCommandSubState]
  1464.                                                 {
  1465.  
  1466.                                                 }
  1467.                                                 [Value2 : cESFIntConst]
  1468.                                                 {
  1469.                                                     Value = -1
  1470.  
  1471.                                                 }
  1472.                                             }
  1473.                                             [Then *]
  1474.                                             {
  1475.  
  1476.                                                 [: cUSetCommandSubState]
  1477.                                                 {
  1478.  
  1479.                                                     [State : cESFIntConst]
  1480.                                                     {
  1481.                                                         Value = 0
  1482.  
  1483.                                                     }
  1484.                                                 }
  1485.                                                 [: cUSetCommandState]
  1486.                                                 {
  1487.  
  1488.                                                     [State : cESFIntConst]
  1489.                                                     {
  1490.                                                         Value = 4
  1491.  
  1492.                                                     }
  1493.                                                 }
  1494.                                             }
  1495.                                             [Else *]
  1496.                                             {
  1497.  
  1498.                                             }
  1499.                                         }
  1500.                                     }
  1501.                                 }
  1502.                                 [: cESCase]
  1503.                                 {
  1504.                                     Note = "6 - Stop"
  1505.                                     Value = 6
  1506.  
  1507.                                     [Procedures *]
  1508.                                     {
  1509.  
  1510.                                         [: cUSetCommandState]
  1511.                                         {
  1512.  
  1513.                                             [State : cESFIntConst]
  1514.                                             {
  1515.                                                 Value = 5
  1516.  
  1517.                                             }
  1518.                                         }
  1519.                                     }
  1520.                                 }
  1521.                             }
  1522.                         }
  1523.                     }
  1524.                 }
  1525.                 [: cESCase]
  1526.                 {
  1527.                     Note = "33 - Wait before first shoot"
  1528.                     Value = 33
  1529.  
  1530.                     [Procedures *]
  1531.                     {
  1532.  
  1533.                         [: cESIf]
  1534.                         {
  1535.                             Note = "Time is out?"
  1536.  
  1537.                             [Condition : cESCNumLess]
  1538.                             {
  1539.                                 Note = ""
  1540.  
  1541.                                 [Value1 : cESFIntByVar]
  1542.                                 {
  1543.                                     VariableName = TimeBeforeShooting
  1544.  
  1545.                                 }
  1546.                                 [Value2 : cESFIntConst]
  1547.                                 {
  1548.                                     Value = 1
  1549.  
  1550.                                 }
  1551.                             }
  1552.                             [Then *]
  1553.                             {
  1554.  
  1555.                                 [: cUSetCommandSubState]
  1556.                                 {
  1557.  
  1558.                                     [State : cESFIntConst]
  1559.                                     {
  1560.                                         Value = 0
  1561.  
  1562.                                     }
  1563.                                 }
  1564.                                 [: cUSetCommandState]
  1565.                                 {
  1566.  
  1567.                                     [State : cESFIntConst]
  1568.                                     {
  1569.                                         Value = 4
  1570.  
  1571.                                     }
  1572.                                 }
  1573.                             }
  1574.                             [Else *]
  1575.                             {
  1576.  
  1577.                                 [: cESIntToVar]
  1578.                                 {
  1579.                                     VariableName = TimeBeforeShooting
  1580.                                     Keep = 1
  1581.  
  1582.                                     [Value : cESFIntAdd]
  1583.                                     {
  1584.  
  1585.                                         [Variable1 : cESFIntByVar]
  1586.                                         {
  1587.                                             VariableName = TimeBeforeShooting
  1588.  
  1589.                                         }
  1590.                                         [Variable2 : cESFIntConst]
  1591.                                         {
  1592.                                             Value = -1
  1593.  
  1594.                                         }
  1595.                                     }
  1596.                                 }
  1597.                             }
  1598.                         }
  1599.                     }
  1600.                 }
  1601.                 [: cESCase]
  1602.                 {
  1603.                     Note = "4 - Wait and shoot"
  1604.                     Value = 4
  1605.  
  1606.                     [Procedures *]
  1607.                     {
  1608.  
  1609.                         [: cESSubrutine]
  1610.                         {
  1611.                             Subrutine = uSub.GetTargetCondition
  1612.  
  1613.                         }
  1614.                         [: cESSwitch]
  1615.                         {
  1616.                             Note = "Switch on TargetCondition"
  1617.  
  1618.                             [Value : cESFIntByVar]
  1619.                             {
  1620.                                 VariableName = TargetCondition
  1621.  
  1622.                             }
  1623.                             [Case *]
  1624.                             {
  1625.  
  1626.                                 [: cESCase]
  1627.                                 {
  1628.                                     Note = "0 "
  1629.                                     Value = 0
  1630.  
  1631.                                     [Procedures *]
  1632.                                     {
  1633.  
  1634.                                         [: cUSetCommandState]
  1635.                                         {
  1636.  
  1637.                                             [State : cESFIntConst]
  1638.                                             {
  1639.                                                 Value = 0
  1640.  
  1641.                                             }
  1642.                                         }
  1643.                                     }
  1644.                                 }
  1645.                                 [: cESCase]
  1646.                                 {
  1647.                                     Note = "1"
  1648.                                     Value = 1
  1649.  
  1650.                                     [Procedures *]
  1651.                                     {
  1652.  
  1653.                                         [: cUSetCommandState]
  1654.                                         {
  1655.  
  1656.                                             [State : cESFIntConst]
  1657.                                             {
  1658.                                                 Value = 0
  1659.  
  1660.                                             }
  1661.                                         }
  1662.                                     }
  1663.                                 }
  1664.                                 [: cESCase]
  1665.                                 {
  1666.                                     Note = "2"
  1667.                                     Value = 2
  1668.  
  1669.                                     [Procedures *]
  1670.                                     {
  1671.  
  1672.                                         [: cUSetCommandState]
  1673.                                         {
  1674.  
  1675.                                             [State : cESFIntConst]
  1676.                                             {
  1677.                                                 Value = 0
  1678.  
  1679.                                             }
  1680.                                         }
  1681.                                     }
  1682.                                 }
  1683.                                 [: cESCase]
  1684.                                 {
  1685.                                     Note = "3"
  1686.                                     Value = 3
  1687.  
  1688.                                     [Procedures *]
  1689.                                     {
  1690.  
  1691.                                         [: cUSetCommandState]
  1692.                                         {
  1693.  
  1694.                                             [State : cESFIntConst]
  1695.                                             {
  1696.                                                 Value = 0
  1697.  
  1698.                                             }
  1699.                                         }
  1700.                                     }
  1701.                                 }
  1702.                                 [: cESCase]
  1703.                                 {
  1704.                                     Note = "4"
  1705.                                     Value = 4
  1706.  
  1707.                                     [Procedures *]
  1708.                                     {
  1709.  
  1710.                                         [: cUFire]
  1711.                                         {
  1712.  
  1713.                                         }
  1714.                                     }
  1715.                                 }
  1716.                                 [: cESCase]
  1717.                                 {
  1718.                                     Note = "5"
  1719.                                     Value = 5
  1720.  
  1721.                                     [Procedures *]
  1722.                                     {
  1723.  
  1724.                                         [: cUSetCommandState]
  1725.                                         {
  1726.  
  1727.                                             [State : cESFIntConst]
  1728.                                             {
  1729.                                                 Value = 0
  1730.  
  1731.                                             }
  1732.                                         }
  1733.                                     }
  1734.                                 }
  1735.                                 [: cESCase]
  1736.                                 {
  1737.                                     Note = "6 - Stop"
  1738.                                     Value = 6
  1739.  
  1740.                                     [Procedures *]
  1741.                                     {
  1742.  
  1743.                                         [: cUSetCommandState]
  1744.                                         {
  1745.  
  1746.                                             [State : cESFIntConst]
  1747.                                             {
  1748.                                                 Value = 5
  1749.  
  1750.                                             }
  1751.                                         }
  1752.                                     }
  1753.                                 }
  1754.                             }
  1755.                         }
  1756.                     }
  1757.                 }
  1758.                 [: cESCase]
  1759.                 {
  1760.                     Note = "5 - Stop"
  1761.                     Value = 5
  1762.  
  1763.                     [Procedures *]
  1764.                     {
  1765.  
  1766.                         [: cESIf]
  1767.                         {
  1768.                             Note = "If it is permitted to stop"
  1769.  
  1770.                             [Condition : cESCNumEquals]
  1771.                             {
  1772.                                 Note = ""
  1773.  
  1774.                                 [Value1 : cESFIntFromMember]
  1775.                                 {
  1776.                                     VariableName = StopBeforeFireCommand
  1777.  
  1778.                                     [Object : cSGetByThisUnit]
  1779.                                     {
  1780.  
  1781.                                     }
  1782.                                 }
  1783.                                 [Value2 : cESFIntConst]
  1784.                                 {
  1785.                                     Value = 1
  1786.  
  1787.                                 }
  1788.                             }
  1789.                             [Then *]
  1790.                             {
  1791.  
  1792.                                 [: cUStop]
  1793.                                 {
  1794.  
  1795.                                     [Entity : cGetThisUnit]
  1796.                                     {
  1797.  
  1798.                                     }
  1799.                                 }
  1800.                             }
  1801.                             [Else *]
  1802.                             {
  1803.  
  1804.                             }
  1805.                         }
  1806.                         [: cESSubrutine]
  1807.                         {
  1808.                             Subrutine = uSub.GetTargetCondition
  1809.  
  1810.                         }
  1811.                         [: cESSwitch]
  1812.                         {
  1813.                             Note = "Switch on TargetCondition"
  1814.  
  1815.                             [Value : cESFIntByVar]
  1816.                             {
  1817.                                 VariableName = TargetCondition
  1818.  
  1819.                             }
  1820.                             [Case *]
  1821.                             {
  1822.  
  1823.                                 [: cESCase]
  1824.                                 {
  1825.                                     Note = "0 - Start, stop, select"
  1826.                                     Value = 0
  1827.  
  1828.                                     [Procedures *]
  1829.                                     {
  1830.  
  1831.                                         [: cUSetCommandState]
  1832.                                         {
  1833.  
  1834.                                             [State : cESFIntConst]
  1835.                                             {
  1836.                                                 Value = 0
  1837.  
  1838.                                             }
  1839.                                         }
  1840.                                     }
  1841.                                 }
  1842.                                 [: cESCase]
  1843.                                 {
  1844.                                     Note = "1 - tul messze"
  1845.                                     Value = 1
  1846.  
  1847.                                     [Procedures *]
  1848.                                     {
  1849.  
  1850.                                         [: cUSetCommandSubState]
  1851.                                         {
  1852.  
  1853.                                             [State : cESFIntConst]
  1854.                                             {
  1855.                                                 Value = 0
  1856.  
  1857.                                             }
  1858.                                         }
  1859.                                         [: cUSetCommandState]
  1860.                                         {
  1861.  
  1862.                                             [State : cESFIntConst]
  1863.                                             {
  1864.                                                 Value = 1
  1865.  
  1866.                                             }
  1867.                                         }
  1868.                                     }
  1869.                                 }
  1870.                                 [: cESCase]
  1871.                                 {
  1872.                                     Note = "2 - GetInPosition (too close)"
  1873.                                     Value = 2
  1874.  
  1875.                                     [Procedures *]
  1876.                                     {
  1877.  
  1878.                                         [: cUSetCommandState]
  1879.                                         {
  1880.  
  1881.                                             [State : cESFIntConst]
  1882.                                             {
  1883.                                                 Value = 0
  1884.  
  1885.                                             }
  1886.                                         }
  1887.                                     }
  1888.                                 }
  1889.                                 [: cESCase]
  1890.                                 {
  1891.                                     Note = "3 - TurnTo"
  1892.                                     Value = 3
  1893.  
  1894.                                     [Procedures *]
  1895.                                     {
  1896.  
  1897.                                         [: cUSetCommandSubState]
  1898.                                         {
  1899.  
  1900.                                             [State : cESFIntConst]
  1901.                                             {
  1902.                                                 Value = 0
  1903.  
  1904.                                             }
  1905.                                         }
  1906.                                         [: cUSetCommandState]
  1907.                                         {
  1908.  
  1909.                                             [State : cESFIntConst]
  1910.                                             {
  1911.                                                 Value = 2
  1912.  
  1913.                                             }
  1914.                                         }
  1915.                                     }
  1916.                                 }
  1917.                                 [: cESCase]
  1918.                                 {
  1919.                                     Note = "4 - GetInPosition (in ideal shoot position) "
  1920.                                     Value = 4
  1921.  
  1922.                                     [Procedures *]
  1923.                                     {
  1924.  
  1925.                                         [: cUSetCommandSubState]
  1926.                                         {
  1927.  
  1928.                                             [State : cESFIntConst]
  1929.                                             {
  1930.                                                 Value = 0
  1931.  
  1932.                                             }
  1933.                                         }
  1934.                                         [: cUSetCommandState]
  1935.                                         {
  1936.  
  1937.                                             [State : cESFIntConst]
  1938.                                             {
  1939.                                                 Value = 3
  1940.  
  1941.                                             }
  1942.                                         }
  1943.                                     }
  1944.                                 }
  1945.                                 [: cESCase]
  1946.                                 {
  1947.                                     Note = "5 - Fire and move"
  1948.                                     Value = 5
  1949.  
  1950.                                     [Procedures *]
  1951.                                     {
  1952.  
  1953.                                         [: cUSetCommandSubState]
  1954.                                         {
  1955.  
  1956.                                             [State : cESFIntConst]
  1957.                                             {
  1958.                                                 Value = 0
  1959.  
  1960.                                             }
  1961.                                         }
  1962.                                         [: cUSetCommandState]
  1963.                                         {
  1964.  
  1965.                                             [State : cESFIntConst]
  1966.                                             {
  1967.                                                 Value = 1
  1968.  
  1969.                                             }
  1970.                                         }
  1971.                                     }
  1972.                                 }
  1973.                                 [: cESCase]
  1974.                                 {
  1975.                                     Note = "6 - Stop"
  1976.                                     Value = 6
  1977.  
  1978.                                     [Procedures *]
  1979.                                     {
  1980.  
  1981.                                         [: cUSetCommandState]
  1982.                                         {
  1983.  
  1984.                                             [State : cESFIntConst]
  1985.                                             {
  1986.                                                 Value = 5
  1987.  
  1988.                                             }
  1989.                                         }
  1990.                                     }
  1991.                                 }
  1992.                             }
  1993.                         }
  1994.                     }
  1995.                 }
  1996.             }
  1997.         }
  1998.     }
  1999. }
  2000.