home *** CD-ROM | disk | FTP | other *** search
/ Joystick Magazine 2002 December / JOY143_CD1.iso / Data / Demos / Platoon / pl_demo.exe / Inf / Gamelogic / GameEvents / uCmd.Mount.inf < prev    next >
INI File  |  2002-10-14  |  13KB  |  765 lines

  1.  
  2. [uCmd.Mount : cESEvent]
  3. {
  4.     Name = uCmd.Mount
  5.     Enabled = 1
  6.     Type = 1
  7.     RefreshRate = 0
  8.  
  9.     [Procedures *]
  10.     {
  11.  
  12.         [: cESNote]
  13.         {
  14.             Text = "Made by Snowman"
  15.  
  16.         }
  17.         [: cESIf]
  18.         {
  19.             Note = "CommandType == MOUNT"
  20.  
  21.             [Condition : cESCNumEquals]
  22.             {
  23.                 Note = ""
  24.  
  25.                 [Value1 : cUGetCommandType]
  26.                 {
  27.  
  28.                 }
  29.                 [Value2 : cUEnumCommand]
  30.                 {
  31.                     ECommand = 22
  32.  
  33.                 }
  34.             }
  35.             [Then *]
  36.             {
  37.  
  38.                 [: cESIf]
  39.                 {
  40.                     Note = "CommandState == 0"
  41.  
  42.                     [Condition : cESCNumEquals]
  43.                     {
  44.                         Note = ""
  45.  
  46.                         [Value1 : cUGetCommandState]
  47.                         {
  48.  
  49.                         }
  50.                         [Value2 : cESFIntConst]
  51.                         {
  52.                             Value = 0
  53.  
  54.                         }
  55.                     }
  56.                     [Then *]
  57.                     {
  58.  
  59.                         [: cESIf]
  60.                         {
  61.                             Note = "ha mar halott a celjarmu akkor done"
  62.  
  63.                             [Condition : cESCNot]
  64.                             {
  65.                                 Note = ""
  66.  
  67.                                 [Condition : cSIsActive]
  68.                                 {
  69.                                     Note = ""
  70.  
  71.                                     [Squad : cUGetCommandTarget]
  72.                                     {
  73.  
  74.                                     }
  75.                                 }
  76.                             }
  77.                             [Then *]
  78.                             {
  79.  
  80.                                 [: cUCommandCompleted]
  81.                                 {
  82.  
  83.                                 }
  84.                                 [: cESBreak]
  85.                                 {
  86.  
  87.                                 }
  88.                             }
  89.                             [Else *]
  90.                             {
  91.  
  92.                             }
  93.                         }
  94.                         [: cUTurnTo]
  95.                         {
  96.  
  97.                             [Target : cUGetCommandTarget]
  98.                             {
  99.  
  100.                             }
  101.                             [TurnToTarget : NULL]
  102.                             {
  103.  
  104.                             }
  105.                         }
  106.                         [: cUSetCommandState]
  107.                         {
  108.  
  109.                             [State : cESFIntConst]
  110.                             {
  111.                                 Value = 1
  112.  
  113.                             }
  114.                         }
  115.                         [: cUClearPassengerContainer]
  116.                         {
  117.  
  118.                             [Target : cUGetCommandTarget]
  119.                             {
  120.  
  121.                             }
  122.                             [TimeStamp : NULL]
  123.                             {
  124.  
  125.                             }
  126.                         }
  127.                     }
  128.                     [Else *]
  129.                     {
  130.  
  131.                         [: cESIf]
  132.                         {
  133.                             Note = "CommandState == 1"
  134.  
  135.                             [Condition : cESCNumEquals]
  136.                             {
  137.                                 Note = ""
  138.  
  139.                                 [Value1 : cUGetCommandState]
  140.                                 {
  141.  
  142.                                 }
  143.                                 [Value2 : cESFIntConst]
  144.                                 {
  145.                                     Value = 1
  146.  
  147.                                 }
  148.                             }
  149.                             [Then *]
  150.                             {
  151.  
  152.                                 [: cESIf]
  153.                                 {
  154.                                     Note = "Can Mount ?"
  155.  
  156.                                     [Condition : cUCanMount]
  157.                                     {
  158.                                         Note = ""
  159.  
  160.                                         [Target : cUGetCommandTarget]
  161.                                         {
  162.  
  163.                                         }
  164.                                         [Passenger : cSGetByThisUnit]
  165.                                         {
  166.  
  167.                                         }
  168.                                     }
  169.                                     [Then *]
  170.                                     {
  171.  
  172.                                         [: cUSetCommandState]
  173.                                         {
  174.  
  175.                                             [State : cESFIntConst]
  176.                                             {
  177.                                                 Value = 2
  178.  
  179.                                             }
  180.                                         }
  181.                                         [: cUAddToPassengerContainer]
  182.                                         {
  183.  
  184.                                             [Target : cUGetCommandTarget]
  185.                                             {
  186.  
  187.                                             }
  188.                                             [Passenger : cGetThisUnit]
  189.                                             {
  190.  
  191.                                             }
  192.                                         }
  193.                                     }
  194.                                     [Else *]
  195.                                     {
  196.  
  197.                                         [: cUCommandCompleted]
  198.                                         {
  199.  
  200.                                         }
  201.                                         [: cESBreak]
  202.                                         {
  203.  
  204.                                         }
  205.                                     }
  206.                                 }
  207.                             }
  208.                             [Else *]
  209.                             {
  210.  
  211.                                 [: cESIf]
  212.                                 {
  213.                                     Note = "CommandState == 2"
  214.  
  215.                                     [Condition : cESCNumEquals]
  216.                                     {
  217.                                         Note = ""
  218.  
  219.                                         [Value1 : cUGetCommandState]
  220.                                         {
  221.  
  222.                                         }
  223.                                         [Value2 : cESFIntConst]
  224.                                         {
  225.                                             Value = 2
  226.  
  227.                                         }
  228.                                     }
  229.                                     [Then *]
  230.                                     {
  231.  
  232.                                         [: cUSetCommandIntParam]
  233.                                         {
  234.  
  235.                                             [Value : cESFIntAdd]
  236.                                             {
  237.  
  238.                                                 [Variable1 : cESFIntConst]
  239.                                                 {
  240.                                                     Value = 5
  241.  
  242.                                                 }
  243.                                                 [Variable2 : cESFIntMul]
  244.                                                 {
  245.  
  246.                                                     [Variable1 : cESFIntConst]
  247.                                                     {
  248.                                                         Value = 10
  249.  
  250.                                                     }
  251.                                                     [Variable2 : cUGetMountOrder]
  252.                                                     {
  253.  
  254.                                                         [Vehicle : cUGetCommandTarget]
  255.                                                         {
  256.  
  257.                                                         }
  258.                                                         [Passenger : cGetThisUnit]
  259.                                                         {
  260.  
  261.                                                         }
  262.                                                     }
  263.                                                 }
  264.                                             }
  265.                                         }
  266.                                         [: cUSetCommandState]
  267.                                         {
  268.  
  269.                                             [State : cESFIntConst]
  270.                                             {
  271.                                                 Value = 3
  272.  
  273.                                             }
  274.                                         }
  275.                                     }
  276.                                     [Else *]
  277.                                     {
  278.  
  279.                                         [: cESIf]
  280.                                         {
  281.                                             Note = "CommandState == 3"
  282.  
  283.                                             [Condition : cESCNumEquals]
  284.                                             {
  285.                                                 Note = ""
  286.  
  287.                                                 [Value1 : cUGetCommandState]
  288.                                                 {
  289.  
  290.                                                 }
  291.                                                 [Value2 : cESFIntConst]
  292.                                                 {
  293.                                                     Value = 3
  294.  
  295.                                                 }
  296.                                             }
  297.                                             [Then *]
  298.                                             {
  299.  
  300.                                                 [: cESIf]
  301.                                                 {
  302.                                                     Note = "IntParam < 1"
  303.  
  304.                                                     [Condition : cESCNumLess]
  305.                                                     {
  306.                                                         Note = ""
  307.  
  308.                                                         [Value1 : cUGetCommandIntParam]
  309.                                                         {
  310.  
  311.                                                         }
  312.                                                         [Value2 : cESFIntConst]
  313.                                                         {
  314.                                                             Value = 1
  315.  
  316.                                                         }
  317.                                                     }
  318.                                                     [Then *]
  319.                                                     {
  320.  
  321.                                                         [: cUSetMoveTarget]
  322.                                                         {
  323.                                                             Translate = 0
  324.  
  325.                                                             [Target : cUGetDummyPos]
  326.                                                             {
  327.                                                                 DummyName = _MOUNTPOS
  328.  
  329.                                                                 [Entity : cUGetCommandTarget]
  330.                                                                 {
  331.  
  332.                                                                 }
  333.                                                             }
  334.                                                         }
  335.                                                         [: cESIf]
  336.                                                         {
  337.                                                             Note = ""
  338.  
  339.                                                             [Condition : cESCNumEquals]
  340.                                                             {
  341.                                                                 Note = ""
  342.  
  343.                                                                 [Value1 : cUGetUnitType]
  344.                                                                 {
  345.  
  346.                                                                     [Entity : cUGetCommandTarget]
  347.                                                                     {
  348.  
  349.                                                                     }
  350.                                                                 }
  351.                                                                 [Value2 : cUUnitTypeEnum]
  352.                                                                 {
  353.                                                                     EUnitType = 2
  354.  
  355.                                                                 }
  356.                                                             }
  357.                                                             [Then *]
  358.                                                             {
  359.  
  360.                                                                 [: cUPlayAnim]
  361.                                                                 {
  362.                                                                     AnimName = MOUNTAPC
  363.  
  364.                                                                     [Target : NULL]
  365.                                                                     {
  366.  
  367.                                                                     }
  368.                                                                     [Direction : cUGetDummyDirection]
  369.                                                                     {
  370.                                                                         DummyName = _MOUNTPOS
  371.  
  372.                                                                         [Entity : cUGetCommandTarget]
  373.                                                                         {
  374.  
  375.                                                                         }
  376.                                                                     }
  377.                                                                 }
  378.                                                             }
  379.                                                             [Else *]
  380.                                                             {
  381.  
  382.                                                                 [: cUPlayAnim]
  383.                                                                 {
  384.                                                                     AnimName = MOUNT
  385.  
  386.                                                                     [Target : NULL]
  387.                                                                     {
  388.  
  389.                                                                     }
  390.                                                                     [Direction : cUGetDummyDirection]
  391.                                                                     {
  392.                                                                         DummyName = _MOUNTPOS
  393.  
  394.                                                                         [Entity : cUGetCommandTarget]
  395.                                                                         {
  396.  
  397.                                                                         }
  398.                                                                     }
  399.                                                                 }
  400.                                                             }
  401.                                                         }
  402.                                                         [: cUSetCommandState]
  403.                                                         {
  404.  
  405.                                                             [State : cESFIntConst]
  406.                                                             {
  407.                                                                 Value = 4
  408.  
  409.                                                             }
  410.                                                         }
  411.                                                         [: cTStartTimer]
  412.                                                         {
  413.                                                             TimerName = MountTimer
  414.  
  415.                                                         }
  416.                                                     }
  417.                                                     [Else *]
  418.                                                     {
  419.  
  420.                                                     }
  421.                                                 }
  422.                                             }
  423.                                             [Else *]
  424.                                             {
  425.  
  426.                                                 [: cESIf]
  427.                                                 {
  428.                                                     Note = "CommandState == 4"
  429.  
  430.                                                     [Condition : cESCNumEquals]
  431.                                                     {
  432.                                                         Note = ""
  433.  
  434.                                                         [Value1 : cUGetCommandState]
  435.                                                         {
  436.  
  437.                                                         }
  438.                                                         [Value2 : cESFIntConst]
  439.                                                         {
  440.                                                             Value = 4
  441.  
  442.                                                         }
  443.                                                     }
  444.                                                     [Then *]
  445.                                                     {
  446.  
  447.                                                         [: cESIf]
  448.                                                         {
  449.                                                             Note = "Timer == 1"
  450.  
  451.                                                             [Condition : cESCNumEquals]
  452.                                                             {
  453.                                                                 Note = ""
  454.  
  455.                                                                 [Value1 : cTGetTimerValue]
  456.                                                                 {
  457.                                                                     TimerName = MountTimer
  458.  
  459.                                                                 }
  460.                                                                 [Value2 : cESFIntConst]
  461.                                                                 {
  462.                                                                     Value = 1
  463.  
  464.                                                                 }
  465.                                                             }
  466.                                                             [Then *]
  467.                                                             {
  468.  
  469.                                                                 [: cUSetMoveTarget]
  470.                                                                 {
  471.                                                                     Translate = 0
  472.  
  473.                                                                     [Target : cUGetDummyPos]
  474.                                                                     {
  475.                                                                         DummyName = _MOUNTPOS
  476.  
  477.                                                                         [Entity : cUGetCommandTarget]
  478.                                                                         {
  479.  
  480.                                                                         }
  481.                                                                     }
  482.                                                                 }
  483.                                                                 [: cESIf]
  484.                                                                 {
  485.                                                                     Note = ""
  486.  
  487.                                                                     [Condition : cESCNumEquals]
  488.                                                                     {
  489.                                                                         Note = ""
  490.  
  491.                                                                         [Value1 : cUGetUnitType]
  492.                                                                         {
  493.  
  494.                                                                             [Entity : cUGetCommandTarget]
  495.                                                                             {
  496.  
  497.                                                                             }
  498.                                                                         }
  499.                                                                         [Value2 : cUUnitTypeEnum]
  500.                                                                         {
  501.                                                                             EUnitType = 2
  502.  
  503.                                                                         }
  504.                                                                     }
  505.                                                                     [Then *]
  506.                                                                     {
  507.  
  508.                                                                         [: cUPlayAnim]
  509.                                                                         {
  510.                                                                             AnimName = MOUNTAPC
  511.  
  512.                                                                             [Target : NULL]
  513.                                                                             {
  514.  
  515.                                                                             }
  516.                                                                             [Direction : cUGetDummyDirection]
  517.                                                                             {
  518.                                                                                 DummyName = _MOUNTPOS
  519.  
  520.                                                                                 [Entity : cUGetCommandTarget]
  521.                                                                                 {
  522.  
  523.                                                                                 }
  524.                                                                             }
  525.                                                                         }
  526.                                                                     }
  527.                                                                     [Else *]
  528.                                                                     {
  529.  
  530.                                                                         [: cUPlayAnim]
  531.                                                                         {
  532.                                                                             AnimName = MOUNT
  533.  
  534.                                                                             [Target : NULL]
  535.                                                                             {
  536.  
  537.                                                                             }
  538.                                                                             [Direction : cUGetDummyDirection]
  539.                                                                             {
  540.                                                                                 DummyName = _MOUNTPOS
  541.  
  542.                                                                                 [Entity : cUGetCommandTarget]
  543.                                                                                 {
  544.  
  545.                                                                                 }
  546.                                                                             }
  547.                                                                         }
  548.                                                                     }
  549.                                                                 }
  550.                                                             }
  551.                                                             [Else *]
  552.                                                             {
  553.  
  554.                                                             }
  555.                                                         }
  556.                                                         [: cESIf]
  557.                                                         {
  558.                                                             Note = "Timer == 10"
  559.  
  560.                                                             [Condition : cESCNumEquals]
  561.                                                             {
  562.                                                                 Note = ""
  563.  
  564.                                                                 [Value1 : cTGetTimerValue]
  565.                                                                 {
  566.                                                                     TimerName = MountTimer
  567.  
  568.                                                                 }
  569.                                                                 [Value2 : cESFIntConst]
  570.                                                                 {
  571.                                                                     Value = 10
  572.  
  573.                                                                 }
  574.                                                             }
  575.                                                             [Then *]
  576.                                                             {
  577.  
  578.                                                                 [: cTStartTimer]
  579.                                                                 {
  580.                                                                     TimerName = MountTimer
  581.  
  582.                                                                 }
  583.                                                             }
  584.                                                             [Else *]
  585.                                                             {
  586.  
  587.                                                             }
  588.                                                         }
  589.                                                     }
  590.                                                     [Else *]
  591.                                                     {
  592.  
  593.                                                     }
  594.                                                 }
  595.                                             }
  596.                                         }
  597.                                     }
  598.                                 }
  599.                             }
  600.                         }
  601.                     }
  602.                 }
  603.                 [: cUDecIntParam]
  604.                 {
  605.                     Value = 1
  606.  
  607.                 }
  608.                 [: cESIf]
  609.                 {
  610.                     Note = "CommandState > 3"
  611.  
  612.                     [Condition : cESCNumGreater]
  613.                     {
  614.                         Note = ""
  615.  
  616.                         [Value1 : cUGetCommandState]
  617.                         {
  618.  
  619.                         }
  620.                         [Value2 : cESFIntConst]
  621.                         {
  622.                             Value = 3
  623.  
  624.                         }
  625.                     }
  626.                     [Then *]
  627.                     {
  628.  
  629.                         [: cESIf]
  630.                         {
  631.                             Note = IsMoveTargetReached
  632.  
  633.                             [Condition : cUIsMoveTargetReached]
  634.                             {
  635.                                 Note = ""
  636.  
  637.                             }
  638.                             [Then *]
  639.                             {
  640.  
  641.                                 [: cEFreeze]
  642.                                 {
  643.                                     GroupName = ""
  644.                                     Time = 10
  645.  
  646.                                     [Target : cUGetCommandTarget]
  647.                                     {
  648.  
  649.                                     }
  650.                                 }
  651.                                 [: cESIf]
  652.                                 {
  653.                                     Note = "CommandState == 4"
  654.  
  655.                                     [Condition : cESCNumEquals]
  656.                                     {
  657.                                         Note = ""
  658.  
  659.                                         [Value1 : cUGetCommandState]
  660.                                         {
  661.  
  662.                                         }
  663.                                         [Value2 : cESFIntConst]
  664.                                         {
  665.                                             Value = 4
  666.  
  667.                                         }
  668.                                     }
  669.                                     [Then *]
  670.                                     {
  671.  
  672.                                         [: cUMount]
  673.                                         {
  674.  
  675.                                             [Target : cUGetCommandTarget]
  676.                                             {
  677.  
  678.                                             }
  679.                                         }
  680.                                         [: cSEnablePlayerControl]
  681.                                         {
  682.                                             Enabled = 0
  683.                                             AutoEnable = 1
  684.                                             ClearSelection = 1
  685.  
  686.                                             [Squad : cSGetByThisUnit]
  687.                                             {
  688.  
  689.                                             }
  690.                                         }
  691.                                         [: cUSetCommandState]
  692.                                         {
  693.  
  694.                                             [State : cESFIntConst]
  695.                                             {
  696.                                                 Value = 5
  697.  
  698.                                             }
  699.                                         }
  700.                                     }
  701.                                     [Else *]
  702.                                     {
  703.  
  704.                                     }
  705.                                 }
  706.                             }
  707.                             [Else *]
  708.                             {
  709.  
  710.                             }
  711.                         }
  712.                     }
  713.                     [Else *]
  714.                     {
  715.  
  716.                     }
  717.                 }
  718.                 [: cESIf]
  719.                 {
  720.                     Note = "Ha a target inactive"
  721.  
  722.                     [Condition : cESCNot]
  723.                     {
  724.                         Note = ""
  725.  
  726.                         [Condition : cSIsActive]
  727.                         {
  728.                             Note = ""
  729.  
  730.                             [Squad : cUGetCommandTarget]
  731.                             {
  732.  
  733.                             }
  734.                         }
  735.                     }
  736.                     [Then *]
  737.                     {
  738.  
  739.                         [: cUStop]
  740.                         {
  741.  
  742.                             [Entity : NULL]
  743.                             {
  744.  
  745.                             }
  746.                         }
  747.                         [: cUCommandCompleted]
  748.                         {
  749.  
  750.                         }
  751.                     }
  752.                     [Else *]
  753.                     {
  754.  
  755.                     }
  756.                 }
  757.             }
  758.             [Else *]
  759.             {
  760.  
  761.             }
  762.         }
  763.     }
  764. }
  765.