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