home *** CD-ROM | disk | FTP | other *** search
/ The Games Machine 76 / XENIATGM66.iso / Messiah / data1.cab / Program_Executable_Files / messiahscripts / BobGen.hxx < prev    next >
Text File  |  1999-11-29  |  22KB  |  914 lines
  1.  
  2.  
  3.         float(_declare,JumpIdleCounter,0);
  4.         float(_declare,JumpPressCounter,0);
  5.         float(_declare,DownwardPull,0);
  6.         float(_declare,TurnSpeed,0);
  7.         float(_declare,ColAngleCorrectNeeded,0);
  8.         float(_declare,ForceRunFrames,0);
  9.         float(_declare,AirSpeedForward,0);
  10.         float(_declare,AirSpeedSideways,0);
  11.         float(_declare,FallStartAltitude,0);
  12.         float(_declare,SmokeCount,500);
  13.         float(_declare,FireCount,0);
  14.         float(_declare,ActionOK,1);
  15.         float(_declare,Hanging,0);
  16.         float(_declare,LastColDistance,0);
  17.         float(_declare,Ledge,0);
  18.         float(_declare,Balance,0);
  19.         float(_declare,BobFlapStrength,0);
  20.         float(_declare,DieCounter,0);
  21.         float(_declare,DragState,0);
  22.         float(_declare,SteamCounter,0);
  23.  
  24.         float(_declare,InvisibleCounter,0);
  25.  
  26.         vector(_declare,LastPos,0,0,0);
  27.  
  28.  
  29.         callsub(Sub_SqueezeCheck,BobCrush);
  30.  
  31.         call(CheckColSphereOffset,BobClimbHang,BobClimbUp,BobFall);
  32.  
  33.         if(VTrigger==_DIRactionhold || VTrigger==_DIRaction)
  34.         {
  35.             Collision(0,0,0,0,0,-50);
  36.             if(VColMaterialProperties==_MATPush)
  37.             {
  38.                 call(MoveBackgroundObject);
  39.             }
  40.         }
  41.  
  42.  
  43.         if(VActorFlag==_AFLAGradiated)
  44.         {
  45.             call(SubtractHealth,0,DamageRadioactive);
  46.             ActorFlag(_clr,_AFLAGradiated);
  47.         }
  48.  
  49.  
  50.  
  51.         if(VActorFlag==_AFLAGnorotation)
  52.         {
  53.             Direction(_clr,_DIRleft);
  54.             Direction(_clr,_DIRright);
  55.         }
  56.         if(VActorFlag==_AFLAGkillandremove)
  57.         {
  58.             print("Kill flag set");
  59.             call(SubtractHealth,0,30000);
  60.         }
  61.  
  62.         if(VHealth<=0)
  63.         {
  64.             Direction(_clr,_DIRalive);
  65.         }
  66.  
  67.  
  68.         ActorFlag(_clr,_AFLAGcolfromabove);
  69.         if(VState==StateFlying || VState==StateGliding || VState==StateFalling)
  70.         {
  71.             Collision(0,0,0,0,50,0);
  72.             if(vcolflag==_DIRhorcol)
  73.             {
  74.                 ActorFlag(_or,_AFLAGcolfromabove);
  75.             }
  76.         }
  77.  
  78.         float(_declare,PlayOnce,0);
  79.         if(VAICon==0 && vstate==statedead && PlayOnce==0)
  80.         {
  81.             message("YOU CALL YOURSELF THE MESSIAH?",400,10);
  82.             callsub(Sub_RandomWalkieKillSFX);
  83.             float(_set,PlayOnce,1);
  84.             //call(ChangeSniperMode,0,0);
  85.         }
  86.         elseif(vstate!=statedead)
  87.         {
  88.             float(_set,PlayOnce,0);
  89.         }
  90. /*
  91.         //Powerup code for invisibility, slowdown and speedup. Not used presently
  92.         if(VKey==Key_O)
  93.         {
  94.             call(AIorder,_set,_AIinvisible);
  95.             float(_set,InvisibleCounter,240);
  96.             call(SetBlendingMode,true,_or,_SXMSubTrans,64);
  97.         }
  98.         elseif(InvisibleCounter>0)
  99.         {
  100.             print("Invisible  ",InvisibleCounter);
  101.             float(_sub,InvisibleCounter,1);
  102.  
  103.             if(InvisibleCounter<30)
  104.             {
  105.                 if(InvisibleCounter&=1)
  106.                 {
  107.                     call(SetBlendingMode,true,0,0,128);
  108.                 }
  109.                 else
  110.                 {
  111.                     call(SetBlendingMode,true,0,0,255);
  112.                 }
  113.             }
  114.  
  115.             if(InvisibleCounter==0)
  116.             {
  117.                 call(AIorder,_clr,_AIinvisible);
  118.                 call(SetBlendingMode,true,_and,_SXMSubTrans,255);
  119.             }
  120.         }
  121.         if(VKey==Key_J)
  122.         {
  123.             call(ClrSlowFastMotion);
  124.         }
  125.         if(VKey==Key_K)
  126.         {
  127.             float(_set,TmpFloat,0.2);
  128.             call(SetSlowFastMotion,false,TmpFloat);
  129.         }
  130.         if(VKey==Key_L)
  131.         {
  132.             call(SetSlowFastMotion,true,2);
  133.         }
  134. */
  135.  
  136. /*        if(vactivetime==10)
  137.         {
  138.             vector(_set,tmpvector,255,255,255);
  139.             vector(_set,Gactorpos,-12098,24789,20870);
  140.             SpawnLight(Lvolumelight,-1,gactorpos,tmpvector,EmptyVector,350);
  141.         }
  142. */
  143.  
  144. /*
  145.         if(vkey==key_v)
  146.         {
  147.             //SpawnAction(BobTaunt);
  148.             SpawnAction(BobFlapWoundLight);
  149.             State(_or,StateExecuteAnim);
  150.         }
  151. */
  152.  
  153.         if(VActor==Bob1)
  154.         {
  155.             Direction(_clr,_DIRdepossesion)
  156.             if(VActiveTime==0)
  157.             {
  158.                 callsub(Sub_ChangeStateToNormal);
  159.                 float(_set,PlayerHeadBone,4);
  160.                 if(VGameCounter!=2)
  161.                 {
  162.     //FirstFrame in Deposess
  163.                     spawnaction(BobDeposses);
  164.                     state(_or,StateExecuteAnim);
  165.                     vector(_settoactorpos,TmpVector);
  166.                     vector(_copyy,TmpVector,FallStartAltitude);
  167.                 }
  168.                 else
  169.                 {
  170.     //First frame in game
  171.                 }
  172.  
  173.             }
  174.             elseif(VActiveTime==1)
  175.             {
  176.                 spawnactor(Halo,0,0,0);
  177.                 call(CheckForPickup,4,_ClassPickup);
  178.  
  179.                 ChangeMaterialFlags(_or,7,_SXMChromaKey,255);
  180.  
  181.                 //call(SubtractHealth,0,-3000);        //bob full health after a depossess (just for now)
  182.             }
  183.         }
  184.  
  185.         if(VColMaterialProperties==_MATDrown || VAction==BobDrown)
  186.         {
  187.             if(VAction!=BobDrown)
  188.             {
  189.                 state(_or,StateExecuteAnim);
  190.                 SpawnAction(BobDrown);
  191.             }
  192.             if(DieCounter==0)
  193.             {
  194.                 state(_or,StateDead);
  195.                 float(_add,DieCounter,1);
  196.                 call(LockCamera,true);
  197.                 move(0,-50,0);
  198.                 direction(_clr,_DIRalive);
  199.             }
  200.             else
  201.             {
  202.                 if(vrnd<15&&DieCounter<60)
  203.                 {
  204.                     callsub(Sub_RandomWaterSFX);
  205.                 }
  206.  
  207.                 float(_add,DieCounter,1);
  208.             }
  209.             move(0,-1,0);
  210.         }
  211.  
  212.         if(VAction==BobFlyDeadFall || VOAction==BobFlyDeadFall)
  213.         {
  214.             if(VTrigger==_DIRhorcol)
  215.             {
  216.                 MoveFeetColOffset(0,25,0);
  217.                 SpawnAction(BobFlyDeadLand);
  218.                 state(_or,StateExecuteAnim|StateDead);
  219.                 CallSub(Sub_ChangeStateToNormal);
  220.             }
  221.         }
  222.         elseif(vstate!=StateDead)
  223.         {
  224.             call(AIupdateAIvars);            //to update aicounters like TimeNotTarget
  225.             call(AIcheckfortarget,10);        //for LineOfSight reasons etc. this is called for player character also
  226.  
  227.             callSub(Sub_ActionKeyHandler,ActionOK);
  228.  
  229.             /*    this is bob's running or standing possesion
  230.  
  231.             call(CheckForJumpPossesion,125,512);
  232.             if(VTrigger==_DIRTempFlag && VTrigger==_DIRjump)
  233.             {
  234.                 state(_or,StateExecuteAnim);
  235.  
  236.                 if(VTrigger==_DIRforward || VTrigger==_DIRbackward)    //maybe include walking aswell
  237.                 {
  238.                     SpawnAction(BobRunJumpPosses);
  239.                 }
  240.                 else
  241.                 {
  242.                     SpawnAction(BobJumpPosses);
  243.                 }
  244.  
  245.                 Direction(_clr,_DIRjump);        //make sure nobody else uses this right now
  246.             }
  247.             */
  248.  
  249.             if(VAction==bobshoot)
  250.             {
  251.                 if(vframe==30)
  252.                 {
  253.                     sample(SFXbobbang,-1);
  254.                 }
  255.                 if(vframe==90)
  256.                 {
  257.                     sample(SFXbobphoomp,-1);
  258.                 }
  259.             }
  260.  
  261.  
  262.             if(VAction!=BobDeposses)
  263.             {
  264.                 if(Vstate==StateFlying||vstate==StateFalling||vstate==StateJump||vstate==StateGliding)
  265.                 {
  266.                     call(CheckForPossesion);    //DiameterSqr
  267.                 }
  268.             }
  269.  
  270.             call(DeadClassRank,true,100);
  271.             CallSub(BackGroundTriggerChecks);
  272.             call(DeadClassRank,false);
  273.  
  274.             callSub(Sub_CheckRemainingActions,BobConsole,20);
  275.  
  276.             callsub(Sub_Headtrack);                    //Track head against object
  277.             CallSub(Sub_CheckFallDamage,AIAbility,BobTouchDown,FallStartAltitude,BobMaxFall,DamageBobFall,BobFallDead,BobBangHead,Bobfall);
  278.         }
  279.  
  280.         callsub(Sub_CheckHit,AIAbility,BobWoundLight,BobWoundLightRun,0,FireCount,BobDead,BobWoundLight,BobThrownForward,BobThrownBack,BobThrownBack,BobThrownBack);
  281.  
  282.         if(vstate==StateHarpooned)
  283.         {
  284.             if(VState!=StateDead)
  285.             {
  286.                 call(SubtractHealth,_COLsingleattach,DamageMaxDamage);
  287.             }
  288.         }
  289.         elseif(vstate==StateOnFire)    //These first if-statements are just for effects
  290.         {
  291.             if(vrnd<20)
  292.             {
  293.                 CheckActorCollision(0,emptyVector,96,0,_COLfire,DamageFlameThrower);
  294.             }
  295.  
  296.             if(FireCount==0)
  297.             {
  298.                 samplestop(SFXbobcoff);
  299.                 sample(SFXBobPainInFire,-1);
  300.                 sample(SFXGenericBurn,-1);
  301.  
  302.                 float(_set,ActorFireType,10);
  303.             }
  304.             callsub(Sub_ActorFireEffect,SmokeCount,FireCount,255)
  305.         }
  306.         elseif(vstate==StateBlind)
  307.         {
  308.             if(SmokeCount==0)
  309.             {
  310.                 samplestop(SFXGenericBurn);
  311.                 sample(SFXbobcoff,-1);
  312.             }
  313.             callsub(Sub_ActorSmokeEffect,SmokeCount,255)
  314.         }
  315.         elseif(VState==StateThrown)
  316.         {
  317.             if (VAction==BobGetUpFromFrontFaceDown || VAction==BobGetUpFromBack)
  318.             {
  319.                 CallSub(sub_ChangeStateToNormal);
  320.             }
  321.         }
  322.  
  323.         callsub(Sub_CheckDeadOrDying,AIAbility,BobDead,BobDead,BobDead,0,0,0,BobDead,BobThrownBack);
  324.  
  325.         CallSub(Sub_CheckClimbUp,bobclimbhang,30,ColAngleCorrectNeeded,20,BobHangMoveIn)
  326.  
  327.         if(VAction==BobClimbHang)    //outside executeanim, because execute is cleared when shimmy left or right
  328.         { 
  329.             if(HelpVar&=Help11 && TutorialToggle==1 && VCurSet=="s1r11")
  330.             {
  331.                 ClearTutorialLines();
  332.                 AddTutorialLine("[20:250:50]Bob[255:255:255] can grab onto ledges and");
  333.                 AddTutorialLine("shimmy left and right. To move");
  334.                 AddTutorialLine("to the left or to the right@");
  335.                 AddTutorialLine("just press your [20:250:50]LEFT[255:255:255] or [20:250:50]RIGHT[255:255:255]");
  336.                 AddTutorialLine("direction key. To climb upon");
  337.                 AddTutorialLine("the ledge@ press [20:250:50]FORWARD[255:255:255]. To");
  338.                 AddTutorialLine("fall back@ press [20:250:50]BACKWARD[255:255:255].");
  339.                 AddTutorialLine(" ");
  340.                 AddTutorialLine("    [255:255:100]             Press Any Key       ");
  341.                 AddTutorialLine("    [255:255:100]             To Continue         ");
  342.                 DisplayTutorialScreen("[255:255:20]Hand-over-hand",15,15);
  343.                 float(_xor,HelpVar,help11);    
  344.             }
  345.             callsub(Sub_CheckHanging,Hanging,BobClimbUp,BobFall,BobHangMoveIn);
  346.             vector(_settoactorpos,LastPos);
  347.         }
  348.         elseif(Hanging==1 && VTrigger==_DIRhorcol)
  349.         {
  350.             float(_set,Hanging,0);    //if said to be hanging but on the ground, reset hang variable
  351. //            MoveFeetColOffset(0,0,BobHangMoveIn);
  352. //            float(_set,TmpFloat,BobHangMoveIn);
  353. //            float(_inv,TmpFloat);
  354. //            move(0,0,TmpFloat);
  355.         }
  356.  
  357.         if(Hanging==1)                //bob is hanging on a ledge
  358.         {
  359.             if(VAction==BobWoundLight || VState==StateThrown)
  360.             {
  361.                 state(_clr,StateExecuteAnim);
  362.                 state(_clr,StateNormal);
  363.                 //SpawnAction(DropDown);
  364.                 state(_or,StateFalling);
  365.                 float(_set,Hanging,0);
  366. //                MoveFeetColOffset(0,0,BobHangMoveIn);
  367. //                float(_set,TmpFloat,BobHangMoveIn);
  368. //                float(_inv,TmpFloat);
  369. //                move(0,0,TmpFloat);
  370.             }
  371.             else
  372.             {
  373.                 if(ColAngleCorrectNeeded!=0)
  374.                 {
  375.                     turn(0,ColAngleCorrectNeeded,0);
  376.                     float(_set,ColAngleCorrectNeeded,0);
  377.                 }
  378.  
  379.                 if(VTrigger==_DIRright || VTrigger==_DIRsideright)
  380.                 {
  381.                     float(_set,TmpFloat,-1);
  382.                 }
  383.                 elseif(VTrigger==_DIRleft || VTrigger==_DIRsideleft)
  384.                 {
  385.                     float(_set,TmpFloat,1);
  386.                 }
  387.                 else
  388.                 {
  389.                     float(_set,TmpFloat,0);
  390.                 }
  391.  
  392.                 vector(_settoactorpos,TmpVector);
  393.                 vector(_sub,TmpVector,LastPos);
  394.                 vector(_copyy,TmpVector,TmpFloat2);
  395.                 float(_inv,TmpFloat2);
  396.                 move(0,TmpFloat2,0);
  397.  
  398.                 if(TmpFloat!=0)            //shimmy left or right
  399.                 {
  400.                     vector(_set,TmpVector,0,30,0);
  401.                     vector(_copy,TmpVector2,TmpVector);
  402.                     float(_seti,TmpFloat2,VColFeetSphereSize);
  403.                     float(_add,TmpFloat2,4);
  404.                     if(VAction==BobClimbHang)
  405.                     {
  406.                         float(_add,TmpFloat2,2);
  407.                     }
  408.                     float(_mul,TmpFloat2,TmpFloat);
  409.                     vector(_setx,TmpVector2,TmpFloat2);
  410.                     Collision(TmpVector,TmpVector2);
  411.                     if(VColFlag==_DIRvercol)
  412.                     {
  413.                         if(TmpFloat==-1)
  414.                         {
  415.                             Direction(_clr,_DIRright|_DIRsideright);
  416.                         }
  417.                         else
  418.                         {
  419.                             Direction(_clr,_DIRleft|_DIRsideleft);
  420.                         }
  421.                     }
  422.                     else                //didn't hit a wall to either side
  423.                     {
  424.                         vector(_copy,TmpVector,TmpVector2);
  425.                         vector(_setz,TmpVector2,-35)
  426.                         Collision(TmpVector,TmpVector2);
  427.                         if(VColFlag!=_DIRvercol)
  428.                         {
  429.                             if(TmpFloat==-1)
  430.                             {
  431.                                 Direction(_clr,_DIRright|_DIRsideright);
  432.                             }
  433.                             else
  434.                             {
  435.                                 Direction(_clr,_DIRleft|_DIRsideleft);
  436.                             }
  437.                         }
  438.                         else            //hit a wall in front and to the side
  439.                         {
  440.                             float(_seti,TmpFloat2,VColSphereSize);
  441.                             float(_add,TmpFloat2,50);
  442.                             vector(_sety,TmpVector,TmpFloat2);
  443.                             vector(_sety,TmpVector2,TmpFloat2);
  444.                             vector(_setz,TmpVector2,-60);
  445.                             Collision(TmpVector,TmpVector2);
  446.                             if(VColFlag==_DIRvercol)    //hit a wall in front, to the side and above
  447.                             {
  448.                                 if(TmpFloat==-1)
  449.                                 {
  450.                                     Direction(_clr,_DIRright|_DIRsideright);
  451.                                 }
  452.                                 else
  453.                                 {
  454.                                     Direction(_clr,_DIRleft|_DIRsideleft);
  455.                                 }
  456.                             }
  457.                         }
  458.                     }
  459.                 }
  460.             }
  461.         }
  462.  
  463.         if(vstate==StateExecuteAnim)
  464.         {
  465.             callsub(Sub_CheckExecuteAnimEnd);
  466. /*            if(vaction==BobFlyBackFlip)
  467.             {
  468.                 callsub(Sub_TurnCharacter,TurnSpeed,BobMaxTurnSpeedAir,0);
  469.                 callsub(Sub_MoveBobInAir,AirSpeedForward,AirSpeedSideways,TurnSpeed,ColAngleCorrectNeeded)
  470.                 callsub(Sub_CheckExecuteAnimEnd)
  471.             }
  472.             
  473. */
  474.             if(VAction==BobFlyDead)
  475.             {
  476.                 turn(0,100,0);
  477.             }
  478.             elseif(VOAction==BobFlyDead)
  479.             {
  480.                 SpawnAction(BobFlyDeadFall);
  481.                 state(_or,StateExecuteAnim);
  482.             }
  483.  
  484.             if(VAction==BobFlyDeadFall)
  485.             {
  486.                 turn(0,100,0);
  487.             }
  488.  
  489.             if(vaction==BobFlyFromSmackWall)
  490.             {
  491.                 callsub(Sub_TurnCharacter,TurnSpeed,BobMaxTurnSpeedAir,0);
  492.                 callsub(Sub_MoveBobInAir,AirSpeedForward,AirSpeedSideways,TurnSpeed,ColAngleCorrectNeeded)
  493.             }
  494.  
  495.             if(VOAction==BobFlySmackWall && vstate!=StateExecuteAnim)
  496.             {
  497.                 //SpawnAction(BobFlyFromSmackWall);
  498.                 State(_or,StateExecuteAnim);
  499.             }
  500.             elseif(VAction==BobDeposses)
  501.             {
  502.                 float(_seti,TmpFloat1,VFrame)
  503.                 float(_set,TmpFloat2,TmpFloat1)
  504.                 float(_mul,TmpFloat1,-0.5)
  505.                 float(_add,TmpFloat1,24)
  506.                 float(_mul,TmpFloat2,-0.8)
  507.                 float(_add,TmpFloat2,14)
  508.                 if(TmpFloat2<0)
  509.                 {
  510.                     float(_set,TmpFloat2,0)
  511.                 }
  512.                 move(0,TmpFloat1,TmpFloat2)
  513.                 callsub(Sub_TurnCharacter,TurnSpeed,BobMaxTurnSpeedAir,0);
  514. //XXX                callsub(Sub_CheckExecuteAnimEnd)
  515.             }
  516.             elseif(VOAction==BobClimbUp && vstate!=StateExecuteAnim)
  517.             {
  518.                 move(0,0,BobHangMoveIn);
  519. //                MoveFeetColOffset(0,0,BobHangMoveIn);
  520.             }
  521.             else
  522.             {
  523. //ClimbUp, ExplosionThrow
  524. //XXX                callsub(Sub_CheckExecuteAnimEnd);
  525.             }
  526.         }
  527. /*        elseif(vstate==StateBangedHead)
  528.         {
  529.             state(_clr,StateBangedHead);
  530.             spawnaction(BobBangHead);
  531.             state(_or,StateExecuteAnim);
  532.         }
  533. */
  534.         elseif(vstate==StateDead)
  535.         {
  536. //Perhaps other states here, like on fire etc.
  537.         }
  538.         else
  539.         {
  540.             //            CallSub(Sub_CheckClimbUp,bobclimbup,30,ColAngleCorrectNeeded,20)
  541.             if(vstate==StateDrag)
  542.             {
  543.                 if(vtrigger!=_DIRactionhold)
  544.                 {
  545.                     spawnaction(BobIdle);
  546.                     call(CheckForGrab,-1);
  547.                 }
  548.                 //callsub(Sub_TurnCharacter,TurnSpeed,BobMaxTurnSpeed,0);
  549.             }
  550.             elseif(vstate==StateElectricShock)
  551.             {
  552. /*                callsub(Sub_ElectricShock,bobelectricshock0,bobelectricshock1);
  553.  
  554.                 //    add correct thrown code here
  555.                 //
  556.  
  557.                 if(vaction==bobelectricshock0)
  558.                 {
  559.                     if(vframe==1)
  560.                     {
  561.                         sample(SFXElectricShock2,-1);
  562.                         call(SubtractHealth,0,DamageElectric);
  563.                     }
  564.                 }
  565.  
  566.                 if(vaction==bobelectricshock1)
  567.                 {
  568.                     if(vframe<15)
  569.                     {
  570.                         move(0,0,6);
  571.                     }
  572.                     if(vendofanim!=0)
  573.                     {
  574.                         state(_change,StateElectricShock,StateNormal);
  575.                     }
  576.                 }
  577. */
  578.                 callsub(Sub_ElectricShock,bobelectricshock0,bobelectricshock1);
  579.  
  580.                 if(vaction==bobelectricshock0)
  581.                 {
  582.                     if(vframe==1)
  583.                     {
  584.                         sample(SFXElectrocuteReact,-1);
  585.                         call(SubtractHealth,0,DamageElectric);
  586.                     }
  587.                 }
  588.                 elseif(voaction==bobelectricshock0)
  589.                 {
  590.                     sample(SFXElectrocuteReact,-1);
  591.  
  592.                     call(PlaneTriggerQuadrant,TmpFloat,1);
  593.                     if(TmpFloat==0)
  594.                     {
  595.                         spawnaction(BobThrownForward);
  596.                         move(0,0,-150);
  597.                     }
  598.                     elseif(TmpFloat==1)
  599.                     {
  600.                         spawnaction(BobThrownBack);        //left
  601.                         move(150,0,0);
  602.                     }
  603.                     elseif(TmpFloat==2)
  604.                     {
  605.                         spawnaction(BobThrownBack);
  606.                         move(0,0,150);
  607.                     }
  608.                     elseif(TmpFloat==3)
  609.                     {
  610.                         spawnaction(BobThrownBack);        //right
  611.                         move(-150,0,0);
  612.                     }
  613.                     state(_clr,StateElectricShock);
  614.                 }
  615.             }
  616.             elseif(vstate==StateNormal && Hanging==0)
  617.             {
  618.                 if(VTrigger==_DIRhorcol && ColMaterial==_MATbalance)
  619.                 {
  620.                     if(Balance==0)
  621.                     {
  622.                         SpawnAction(BobBalanceIdle);
  623.                         float(_set,Balance,1);
  624.                     }
  625.                 }
  626.                 elseif(Balance==1)
  627.                 {
  628.                     float(_set,Balance,0);
  629.                     SpawnAction(BobIdle);
  630.                 }
  631.  
  632.                 if(VTrigger==_DIRhorcol && ColMaterial==_MATledge)
  633.                 {
  634.                     if(Ledge==0)
  635.                     {
  636.                         SpawnAction(BobLedgeIdle);
  637.                         float(_set,Ledge,1);
  638.                     }
  639.                 }
  640.                 elseif(Ledge==1)
  641.                 {
  642.                     float(_set,Ledge,0);
  643.                     SpawnAction(BobIdle);
  644.                 }
  645.  
  646.  
  647.                 callsub(Sub_CheckForIdleLongTime,BobIdle,BobIdleLongTime);
  648.  
  649.                 if(VAction==BobDeposses)
  650.                 {
  651.                     spawnaction(BobDepossesDaze);
  652.                 }
  653.                 rotatebone(0,0,0,0);    //Correct after landing on ground.
  654.  
  655.                 if(VState!=StateCrouching)
  656.                 {
  657.                     callsub(sub_AlignToWallAndCheckRunUpStairs,BobRunUpStairs,BobIdle,BobIdleHitWall,ColAngleCorrectNeeded,BobIdleHitWallFront,BobHitWallSpreadOut,-0.33,BobSpreadOut,0,ForceRunFrames)
  658.                 }
  659.  
  660.                 CallSub(Sub_CheckCrouching,BobCrouchDown,BobCrouchUp);
  661.  
  662.                 CallSub(Sub_CheckJumpFallDown,AIAbility,BobRunUpStairs,JumpPressCounter,DownwardPull,0,BobJump,AirSpeedForward,AirSpeedSideways,BobFall,0);
  663.                 CallSub(Sub_CheckSliding,BobRunUpStairs,BobSlide);
  664.  
  665.                 if(vtrigger==_DIRaction)
  666.                 {
  667. /*    disabling dragging ability
  668.                     call(CheckForGrab,100,TmpFloat);    //Deletes diraction flag if there is no grap possible  !??!
  669.                     float(_set,DragState,TmpFloat);
  670.                     Print("DragState: ",DragState);
  671.                     if(DragState!=0)
  672.                     {
  673.                         if(DragState&=16)                            //on stomach
  674.                         {
  675.                             if(DragState&=1)
  676.                             {
  677.                                 spawnaction(BobDragHeadStomach);
  678.                             }
  679.                             elseif(DragState&=2)
  680.                             {
  681.                                 spawnaction(BobStomachRollRight);
  682.                             }
  683.                             elseif(DragState&=4)
  684.                             {
  685.                                 spawnaction(BobDragFeetStomach);
  686.                             }
  687.                             elseif(DragState&=8)
  688.                             {
  689.                                 spawnaction(BobStomachRollLeft);
  690.                             }
  691.                         }
  692.                         else                                        //on back
  693.                         {
  694.                             if(DragState&=1)
  695.                             {
  696.                                 spawnaction(BobDragHead);
  697.                             }
  698.                             elseif(DragState&=2)
  699.                             {
  700.                                 spawnaction(BobBackRollRight);
  701.                             }
  702.                             elseif(DragState&=4)
  703.                             {
  704.                                 spawnaction(BobDragFeet);
  705.                             }
  706.                             elseif(DragState&=8)
  707.                             {
  708.                                 spawnaction(BobBackRollLeft);
  709.                             }
  710.                         }
  711.                     }
  712. */
  713.                 }
  714.                 elseif(vtrigger!=_DIRactionhold)
  715.                 {
  716.                     float(_set,DragState,0);
  717.                 }
  718.  
  719.  
  720.                 if(Ledge==0)
  721.                 {
  722.                     callsub(Sub_TurnCharacter,TurnSpeed,BobMaxTurnSpeed,0);
  723.                 }
  724.                 else
  725.                 {
  726.                     CallSub(Sub_AlignToWallOnLedge,20);
  727.                 }
  728.             }
  729.             elseif(vstate==StateFalling)
  730.             {
  731.                 if(vtrigger==_DIRjump)
  732.                 {
  733.                     float(_set,BobFlapStrength,0);
  734.                     float(_set,JumpPressCounter,0)
  735.                     state(_change,StateFalling,StateFlying);
  736.                 }
  737.                 callsub(Sub_TurnCharacter,TurnSpeed,BobMaxTurnSpeedAir,0);
  738.                 callsub(Sub_MoveBobInAir,AirSpeedForward,AirSpeedSideways,TurnSpeed,ColAngleCorrectNeeded)
  739.                 CallSub(Sub_CheckSliding,BobRunUpStairs,BobSlide);
  740.             }
  741.             elseif(vstate==StateJump)
  742.             {
  743.                 if(vaction!=BobJump)
  744.                 {
  745.                     float(_set,BobFlapStrength,0);
  746.                 }
  747.                 CallSub(Sub_Jump,JumpPressCounter,DownwardPull,BobMinHoldJumpAction,0,0,BobFall)
  748.                 if(vstate==StateFlying)
  749.                 {
  750.                     float(_set,BobFlapStrength,-1);    //Because first doesn't count when holding down
  751.                 }
  752.                 callsub(Sub_TurnCharacter,TurnSpeed,BobMaxTurnSpeedAir,0);
  753.                 callsub(Sub_MoveBobInAir,AirSpeedForward,AirSpeedSideways,TurnSpeed,ColAngleCorrectNeeded)
  754.             }
  755.             elseif(vstate==StateFlying)    //Flapping
  756.             {
  757.                 if(BobFlapStrength>-1&&BobFlappingEnabled==0)
  758.                 {
  759.                     float(_set,SubSubParm1,BobFall)
  760.                     callsub(Sub_InitFall)
  761.                 }
  762.                 else
  763.                 {
  764.                     if(vtrigger==_DIRactorbulletcol)
  765.                     {
  766.                         SpawnAction(BobFlapWoundLight);
  767.                     }
  768.                     else
  769.                     {
  770.                         spawnaction(BobFlap);
  771.  
  772.                         callsub(Sub_BobFlapControl,BobFlapStrength);
  773.                         callsub(Sub_InAirCheckGround,BobTouchDown);
  774.  
  775.                         if(vtrigger==_DIRjump)
  776.                         {
  777.                             float(_set,JumpIdleCounter,0);
  778.                             float(_add,JumpPressCounter,1);
  779.                             if(JumpPressCounter>BobFlapPressThreshold)
  780.                             {
  781.                                 state(_change,StateFlying,StateGliding);
  782.                             }
  783.                         }
  784.                         else
  785.                         {
  786.                             float(_set,JumpPressCounter,0)
  787.                             float(_add,JumpIdleCounter,1);
  788.                             if(JumpIdleCounter<10)
  789.                             {
  790.                                 float(_add,BobFlapStrength,0.3);
  791.                             }
  792.                             else
  793.                             {
  794.                                 float(_set,JumpIdleCounter,0);
  795.                                 float(_set,SubSubParm1,BobFall)
  796.                                 callsub(Sub_InitFall)
  797.                             }
  798.                         }
  799.                     }
  800.                 }
  801.                 if(BobFlapStrength>1)
  802.                 {
  803.                     float(_sub,DownwardPull,BobGravityFlap);
  804.                 }
  805.                 else
  806.                 {
  807.                     float(_sub,DownwardPull,BobGravityGlide);
  808.                 }
  809.                 move(0,DownwardPull,0);
  810.                 callsub(Sub_TurnCharacter,TurnSpeed,BobMaxTurnSpeedAir,0);
  811.                 callsub(Sub_MoveBobInAir,AirSpeedForward,AirSpeedSideways,TurnSpeed,ColAngleCorrectNeeded)
  812.             }
  813.             elseif(vstate==StateGliding)
  814.             {
  815.                 spawnaction(BobGlide);
  816.                 callsub(Sub_InAirCheckGround,BobIdle);
  817.  
  818.                 if(vtrigger==_DIRjump)
  819.                 {
  820.                     if(JumpPressCounter==0)
  821.                     {
  822.                         state(_change,StateGliding,StateFlying);
  823.                     }
  824.                 }
  825.                 else
  826.                 {
  827.                     float(_set,SubSubParm1,BobFall)
  828.                     callsub(Sub_InitFall)
  829.                 }
  830.                 float(_sub,DownwardPull,BobGravityGlide);
  831.                 move(0,DownwardPull,0);
  832.                 callsub(Sub_TurnCharacter,TurnSpeed,BobMaxTurnSpeedAir,0);
  833.                 callsub(Sub_MoveBobInAir,AirSpeedForward,AirSpeedSideways,TurnSpeed,ColAngleCorrectNeeded)
  834.             }
  835.         }
  836.  
  837.         //Bobs Sound FX
  838.         if(vaction==bobflap||vaction==bobjump)
  839.         {
  840.             if(vframe==0)
  841.             {
  842.                 sample(SFXBobFlap,-1);
  843.             }
  844.             elseif(vframe<=1)
  845.             {
  846.                 sample(SFXBobFlap,-1);
  847.             }
  848.             elseif(vframe<=2)
  849.             {
  850.                 sample(SFXBobFlap,-1);
  851.             }
  852.             elseif(vframe<=3)
  853.             {
  854.                 sample(SFXBobFlap,-1);
  855.             }
  856.         }
  857.  
  858.  
  859.         call(CheckAttached,_CANormal);
  860. //        callsub(Sub_CheckForPickups);
  861.  
  862.  
  863.         float(_declare,footsampleb,0);
  864.         if(VAICon==0 && vtrigger==_DIRleft||vtrigger==_DIRright||vtrigger==_DIRforward||vtrigger==_DIRbackward||vtrigger==_DIRsideleft||vtrigger==_DIRsideright)
  865.         {
  866.             if(VSpecialFlag==_sFLAGTrodInGoo)
  867.             {
  868.                 if(vrnd<50)
  869.                 {
  870.                     spawnparticle(fx_footbloodspray,20,emptyvector,emptyvector,-1);
  871.                 }
  872.                 else
  873.                 {
  874.                     spawnparticle(fx_footbloodspray,24,emptyvector,emptyvector,-1);
  875.                 }
  876.                 if(footsampleb==0)
  877.                 {
  878.                     float(_set,footsampleb,25);
  879.                     sample(SFXBlood2,-1);
  880.                 }
  881.             }
  882.             else
  883.             {
  884.                 callsub(Sub_CheckFootSteps,_sFLAGLeftFoot);
  885.                 callsub(Sub_CheckFootSteps,_sFLAGRightFoot);
  886.             }
  887.             if(footsampleb>0)
  888.             {
  889.                 float(_sub,footsampleb,1);
  890.             }
  891.         }
  892.  
  893.         if(VState==StateForceField)
  894.         {
  895.             State(_clr,StateForceField);
  896.  
  897.             float(_set,DownWardPull,0);
  898.             float(_set,BobFlapStrength,0);
  899.             float(_set,JumpPressCounter,0)
  900.         }
  901.  
  902.         if(VState==StateSteamed)
  903.         {
  904.             if(SteamCounter==30)
  905.             {
  906.                 float(_set,SteamCounter,0);
  907.                 state(_clr,StateSteamed);
  908.             }
  909.             else
  910.             {
  911.                 float(_add,SteamCounter,1);
  912.             }
  913.         }
  914.