API tools faq
paste
Advertisement
techforce

Reaperbot move

techforce
Sep 9th, 2011
472
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Clone C 16.18 KB | None | 0 0
raw download clone embed print report
  1.  
  2. void () halfwalkmove =
  3. {
  4.     walkmove (self.strafeyaw, self.strafedist);
  5.     self.think = self.strafethink;
  6.     self.nextthink = (time + 0.05);
  7. };
  8.  
  9. float (float s_yaw, float s_dist) botwalkmove =
  10. {
  11.     local float halfdist;
  12.  
  13.     self.oldorigin = self.origin;
  14.     if ((self.skil > FL_SWIM))
  15.     {
  16.         halfdist = (0.55 * s_dist);
  17.     }
  18.     else
  19.     {
  20.         halfdist = (0.5 * s_dist);
  21.     }
  22.     if (!walkmove (s_yaw, halfdist))
  23.     {
  24.         return (FALSE);
  25.     }
  26.     self.strafethink = self.think;
  27.     self.strafeyaw = s_yaw;
  28.     self.strafedist = halfdist;
  29.     self.think = halfwalkmove;
  30.     self.nextthink = (time + 0.05);
  31.     return (TRUE);
  32. };
  33.  
  34. float (float dist) teleptest =
  35. {
  36.     local vector start;
  37.     local vector up;
  38.  
  39.     up = self.origin;
  40.     start = self.origin;
  41.     if ((dist < FALSE))
  42.     {
  43.         up_z = ((self.absmin_z + dist) - TRUE);
  44.     }
  45.     else
  46.     {
  47.         up_z = ((self.absmax_z + dist) + TRUE);
  48.     }
  49.     traceline (start, up, FALSE, self);
  50.     if ((trace_fraction < TRUE))
  51.     {
  52.         return (FALSE);
  53.     }
  54.     start_x = (start_x + FL_INWATER);
  55.     start_y = (start_y + FL_INWATER);
  56.     up_x = (up_x + FL_INWATER);
  57.     up_y = (up_y + FL_INWATER);
  58.     traceline (start, up, FALSE, self);
  59.     if ((trace_fraction < TRUE))
  60.     {
  61.         return (FALSE);
  62.     }
  63.     start_x = (start_x - FL_MONSTER);
  64.     up_x = (up_x - FL_MONSTER);
  65.     traceline (start, up, FALSE, self);
  66.     if ((trace_fraction < TRUE))
  67.     {
  68.         return (FALSE);
  69.     }
  70.     start_y = (start_y - FL_MONSTER);
  71.     up_y = (up_y - FL_MONSTER);
  72.     traceline (start, up, FALSE, self);
  73.     if ((trace_fraction < TRUE))
  74.     {
  75.         return (FALSE);
  76.     }
  77.     start_x = (start_x + FL_MONSTER);
  78.     up_x = (up_x + FL_MONSTER);
  79.     traceline (start, up, FALSE, self);
  80.     if ((trace_fraction < TRUE))
  81.     {
  82.         return (FALSE);
  83.     }
  84.     start = self.origin;
  85.     start_z = up_z;
  86.     up = start;
  87.     start_x = (start_x + FL_INWATER);
  88.     up_x = (up_x - FL_INWATER);
  89.     traceline (start, up, FALSE, self);
  90.     if ((trace_fraction < TRUE))
  91.     {
  92.         return (FALSE);
  93.     }
  94.     start = self.origin;
  95.     start_z = up_z;
  96.     up = start;
  97.     start_y = (start_y + FL_INWATER);
  98.     up_y = (up_y - FL_INWATER);
  99.     traceline (start, up, FALSE, self);
  100.     if ((trace_fraction < TRUE))
  101.     {
  102.         return (FALSE);
  103.     }
  104.     return (TRUE);
  105. };
  106.  
  107. float (float dist) waterupz =
  108. {
  109.     local vector start;
  110.     local vector up;
  111.  
  112.     if (!teleptest (dist))
  113.     {
  114.         return (FALSE);
  115.     }
  116.     up = self.origin;
  117.     up_z = (up_z + dist);
  118.     setorigin (self, up);
  119.     return (TRUE);
  120. };
  121.  
  122. float (float dist) waterdownz =
  123. {
  124.     local vector up;
  125.     local vector start;
  126.  
  127.     if (!teleptest ((CONTENT_EMPTY * dist)))
  128.     {
  129.         return (FALSE);
  130.     }
  131.     up = self.origin;
  132.     up_z = (up_z - dist);
  133.     setorigin (self, up);
  134.     return (TRUE);
  135. };
  136.  
  137. float (vector jmpv) Botjump =
  138. {
  139.     if ((self.flags & FL_ONGROUND))
  140.     {
  141.         self.flags = (self.flags - FL_ONGROUND);
  142.     }
  143.     self.velocity = jmpv;
  144.     return (TRUE);
  145. };
  146.  
  147. float (vector jmpv) Botwaterjump =
  148. {
  149.     if ((self.flags & FL_ONGROUND))
  150.     {
  151.         self.flags = (self.flags - FL_ONGROUND);
  152.     }
  153.     if (!waterupz (45))
  154.     {
  155.         return (FALSE);
  156.     }
  157.     jmpv_z = 200;
  158.     self.velocity = jmpv;
  159.     if ((self.flags & FL_SWIM))
  160.     {
  161.         self.flags = (self.flags - FL_SWIM);
  162.     }
  163.     if ((self.flags & FL_INWATER))
  164.     {
  165.         self.flags = (self.flags - FL_INWATER);
  166.     }
  167.     self.teleport_time = (time + 0.7);
  168.     return (TRUE);
  169. };
  170. float (entity targ) Swimto;
  171.  
  172. float (vector spot) CheckLavaOrLow =
  173. {
  174.     local float lnd;
  175.     local float boost;
  176.     local vector spot2;
  177.  
  178.     lnd = pointcontents (spot);
  179.     if (((lnd == CONTENT_LAVA) || (lnd == CONTENT_SLIME)))
  180.     {
  181.         return (TRUE);
  182.     }
  183.     spot2 = spot;
  184.     spot2_z = (spot_z + FL_CLIENT);
  185.     lnd = pointcontents (spot2);
  186.     if (((lnd == CONTENT_LAVA) || (lnd == CONTENT_SLIME)))
  187.     {
  188.         return (TRUE);
  189.     }
  190.     if ((lnd != CONTENT_WATER))
  191.     {
  192.         boost = (MAXJUMP + TRUE);
  193.         if ((self.goalentity.goalentity.classname == "func_button"))
  194.         {
  195.             boost = ((boost + self.maxs_z) - TRUE);
  196.         }
  197.         if (((spot_z + boost) < self.goalentity.origin_z))
  198.         {
  199.             return (TRUE);
  200.         }
  201.     }
  202.     else
  203.     {
  204.         traceline (spot2, self.goalentity.absmin, TRUE, self);
  205.         if (trace_inopen)
  206.         {
  207.             if (((spot_z + 45) > self.goalentity.origin_z))
  208.             {
  209.                 return (FALSE);
  210.             }
  211.             return (TRUE);
  212.         }
  213.         if ((trace_fraction == TRUE))
  214.         {
  215.             return (FALSE);
  216.         }
  217.         return (TRUE);
  218.     }
  219.     return (FALSE);
  220. };
  221.  
  222. float (vector middle) checkLanding =
  223. {
  224.     local float goodcnt;
  225.     local vector spot;
  226.     local vector center;
  227.  
  228.     center = middle;
  229.     spot = middle;
  230.     spot_x = (spot_x + MOVETYPE_TOSS);
  231.     if ((pointcontents (spot) == CONTENT_SOLID))
  232.     {
  233.         center_x = (center_x - MOVETYPE_TOSS);
  234.     }
  235.     spot_x = (spot_x - 12);
  236.     if ((pointcontents (spot) == CONTENT_SOLID))
  237.     {
  238.         center_x = (center_x + MOVETYPE_TOSS);
  239.     }
  240.     spot = middle;
  241.     spot_y = (spot_y + MOVETYPE_TOSS);
  242.     if ((pointcontents (spot) == CONTENT_SOLID))
  243.     {
  244.         center_y = (center_y - MOVETYPE_TOSS);
  245.     }
  246.     spot_y = (spot_y - 12);
  247.     if ((pointcontents (spot) == CONTENT_SOLID))
  248.     {
  249.         center_y = (center_y + MOVETYPE_TOSS);
  250.     }
  251.     spot = center;
  252.     spot_z = dropline (spot);
  253.     goodcnt = MOVETYPE_FLY;
  254.     if (CheckLavaOrLow (spot))
  255.     {
  256.         return (FALSE);
  257.     }
  258.     spot = center;
  259.     spot_x = (spot_x + MOVETYPE_TOSS);
  260.     spot_z = dropline (spot);
  261.     if (CheckLavaOrLow (spot))
  262.     {
  263.         goodcnt = (goodcnt - TRUE);
  264.     }
  265.     spot = center;
  266.     spot_x = (spot_x - MOVETYPE_TOSS);
  267.     spot_z = dropline (spot);
  268.     if (CheckLavaOrLow (spot))
  269.     {
  270.         goodcnt = (goodcnt - TRUE);
  271.     }
  272.     spot = center;
  273.     spot_y = (spot_y + MOVETYPE_TOSS);
  274.     spot_z = dropline (spot);
  275.     if (CheckLavaOrLow (spot))
  276.     {
  277.         goodcnt = (goodcnt - TRUE);
  278.     }
  279.     spot = center;
  280.     spot_y = (spot_y - MOVETYPE_TOSS);
  281.     spot_z = dropline (spot);
  282.     if (CheckLavaOrLow (spot))
  283.     {
  284.         goodcnt = (goodcnt - TRUE);
  285.     }
  286.     if ((goodcnt > MOVETYPE_WALK))
  287.     {
  288.         return (TRUE);
  289.     }
  290.     return (FALSE);
  291. };
  292.  
  293. float (float dist) JumpUpToPush =
  294. {
  295.     local float len;
  296.     local vector botxy;
  297.     local vector goalxy;
  298.     local vector xydir;
  299.     local vector jumpv;
  300.  
  301.     botxy = self.origin;
  302.     botxy_z = FALSE;
  303.     goalxy = self.goalentity.origin;
  304.     goalxy_z = FALSE;
  305.     xydir = normalize ((goalxy - botxy));
  306.     len = vlen ((goalxy - botxy));
  307.     if ((len < 25))
  308.     {
  309.         jumpv = (xydir * KINDA_WANT);
  310.         jumpv_z = 270;
  311.         Botjump (jumpv);
  312.         return (TRUE);
  313.     }
  314.     if ((len < 80))
  315.     {
  316.         jumpv = (xydir * (len / LEVELJUMPTIME));
  317.         jumpv_z = 270;
  318.         Botjump (jumpv);
  319.         return (TRUE);
  320.     }
  321.     return (FALSE);
  322. };
  323.  
  324. float (float vz, float dist, float imagine) Bot_tryjump =
  325. {
  326.     local float timetofloor;
  327.     local float tvel;
  328.     local float dis;
  329.     local float diffz;
  330.     local float diffxy;
  331.     local float NOTLAND;
  332.     local float lnd;
  333.     local float len;
  334.     local float depth;
  335.     local float wlevel;
  336.     local float velz;
  337.     local float ht;
  338.     local float frac;
  339.     local vector botxy;
  340.     local vector goalxy;
  341.     local vector xydir;
  342.     local vector top;
  343.     local vector bottom;
  344.     local vector jumpv;
  345.     local vector newtop;
  346.     local vector newbottom;
  347.     local vector back;
  348.     local vector front;
  349.     local vector dir;
  350.     local vector start;
  351.     local string tmp;
  352.     local entity botTarget;
  353.  
  354.     if (!(self.flags & (FL_ONGROUND + FL_SWIM)))
  355.     {
  356.         return (FALSE);
  357.     }
  358.     wlevel = CheckWaterLevel ();
  359.     if ((wlevel > FL_SWIM))
  360.     {
  361.         return (FALSE);
  362.     }
  363.     if (!FacingIdeal ())
  364.     {
  365.         ChangeYaw ();
  366.         if (!FacingIdeal ())
  367.         {
  368.             ChangeYaw ();
  369.             if (!FacingIdeal ())
  370.             {
  371.                 ChangeYaw ();
  372.             }
  373.         }
  374.     }
  375.     makevectors (self.angles);
  376.     start = (self.origin + (FL_INWATER * v_forward));
  377.     botTarget = self.goalentity;
  378.     velz = vz;
  379.     if ((wlevel >= TRUE))
  380.     {
  381.         if ((velz > 200))
  382.         {
  383.             velz = 200;
  384.         }
  385.     }
  386.     if ((wlevel == FL_SWIM))
  387.     {
  388.         if ((botTarget.origin_z < self.origin_z))
  389.         {
  390.             return (FALSE);
  391.         }
  392.         start_z = (start_z + 45);
  393.     }
  394.     botxy = self.origin;
  395.     botxy_z = FALSE;
  396.     diffz = ((start_z - botTarget.origin_z) + TRUE);
  397.     if ((diffz < (CONTENT_EMPTY * MAXJUMP)))
  398.     {
  399.         if ((botTarget.goalentity.classname != "trigger_push"))
  400.         {
  401.             return (FALSE);
  402.         }
  403.         else
  404.         {
  405.             if ((diffz < FALSE))
  406.             {
  407.                 if (JumpUpToPush (dist))
  408.                 {
  409.                     return (TRUE);
  410.                 }
  411.             }
  412.         }
  413.     }
  414.     dis = dist;
  415.     goalxy = botTarget.origin;
  416.     if ((botTarget.goalentity.classname == "train"))
  417.     {
  418.         goalxy = (goalxy + (LEVELJUMPTIME * botTarget.goalentity.velocity));
  419.     }
  420.     lnd = pointcontents (goalxy);
  421.     if (((lnd == CONTENT_LAVA) || (lnd == CONTENT_SLIME)))
  422.     {
  423.         return (FALSE);
  424.     }
  425.     goalxy_z = FALSE;
  426.     xydir = normalize ((goalxy - botxy));
  427.     diffxy = vlen ((goalxy - botxy));
  428.     if ((wlevel == FL_SWIM))
  429.     {
  430.         if ((diffxy > (MOVETYPE_WALK * BOTSPEED)))
  431.         {
  432.             diffxy = (MOVETYPE_WALK * BOTSPEED);
  433.         }
  434.     }
  435.     bottom = (start + self.view_ofs);
  436.     top = (bottom + (xydir * dis));
  437.     top_z = (top_z + (0.1 * (velz - GRAVITY)));
  438.     traceline (bottom, top, TRUE, self);
  439.     if ((trace_fraction != TRUE))
  440.     {
  441.         if ((velz > (GRAVITY + 180)))
  442.         {
  443.             return (Bot_tryjump ((velz - GRAVITY), dist, imagine));
  444.         }
  445.         else
  446.         {
  447.             return (FALSE);
  448.         }
  449.     }
  450.     bottom = (start - (FL_INWATER * v_forward));
  451.     bottom_z = (bottom_z + self.mins_z);
  452.     top = (bottom + ((xydir * dis) * FL_SWIM));
  453.     top_z = ((top_z + (0.2 * (velz - GRAVITY))) - (0.1 * GRAVITY));
  454.     traceline (bottom, top, TRUE, self);
  455.     if ((trace_fraction != TRUE))
  456.     {
  457.         if ((diffxy > (1.9 * BOTSPEED)))
  458.         {
  459.             diffxy = (1.9 * BOTSPEED);
  460.         }
  461.         top = (bottom + (xydir * dis));
  462.         top_z = ((top_z + (0.2 * (velz - GRAVITY))) - (0.1 * GRAVITY));
  463.         traceline (bottom, top, TRUE, self);
  464.         if ((trace_fraction != TRUE))
  465.         {
  466.             if ((diffxy > (0.9 * BOTSPEED)))
  467.             {
  468.                 diffxy = (0.9 * BOTSPEED);
  469.             }
  470.             velz = 290;
  471.         }
  472.     }
  473.     timetofloor = FALSE;
  474.     tvel = velz;
  475.     if ((diffz < FALSE))
  476.     {
  477.         timetofloor = 0.3;
  478.     }
  479.     else
  480.     {
  481.         while ((diffz > FALSE))
  482.         {
  483.             timetofloor = (timetofloor + 0.1);
  484.             tvel = (tvel - GRAVITY);
  485.             diffz = (diffz + (tvel * 0.1));
  486.         }
  487.         timetofloor = (timetofloor - (diffz / tvel));
  488.     }
  489.     if ((diffxy < ((dis * MOVETYPE_BOUNCE) * timetofloor)))
  490.     {
  491.         jumpv = (xydir * (diffxy / timetofloor));
  492.     }
  493.     else
  494.     {
  495.         jumpv = (xydir * (MOVETYPE_BOUNCE * dis));
  496.         if (imagine)
  497.         {
  498.             return (FALSE);
  499.         }
  500.     }
  501.     tvel = velz;
  502.     bottom = start;
  503.     bottom_z = (bottom_z + self.mins_z);
  504.     ht = (self.view_ofs_z - self.mins_z);
  505.     NOTLAND = TRUE;
  506.     while (NOTLAND)
  507.     {
  508.         tvel = (tvel - GRAVITY);
  509.         newbottom = (bottom + (jumpv * 0.1));
  510.         newbottom_z = (newbottom_z + (tvel * 0.1));
  511.         traceline (bottom, newbottom, TRUE, self);
  512.         frac = trace_fraction;
  513.         if ((trace_fraction == TRUE))
  514.         {
  515.             newtop = newbottom;
  516.             top = bottom;
  517.             top_z = (top_z + ht);
  518.             newtop_z = (newtop_z + ht);
  519.             traceline (top, newtop, TRUE, self);
  520.             if ((trace_fraction == TRUE))
  521.             {
  522.                 traceline (newbottom, newtop, TRUE, self);
  523.             }
  524.             if ((trace_fraction == TRUE))
  525.             {
  526.                 top = (top + (FL_INWATER * v_right));
  527.                 newtop = (newtop + (FL_INWATER * v_right));
  528.                 traceline (top, newtop, TRUE, self);
  529.             }
  530.             if ((trace_fraction == TRUE))
  531.             {
  532.                 top = (top - (FL_MONSTER * v_right));
  533.                 newtop = (newtop - (FL_MONSTER * v_right));
  534.                 traceline (top, newtop, TRUE, self);
  535.             }
  536.             if ((trace_fraction != TRUE))
  537.             {
  538.                 frac = 0.1;
  539.             }
  540.         }
  541.         if ((trace_fraction != TRUE))
  542.         {
  543.             dir = normalize ((newbottom - bottom));
  544.             len = vlen ((newbottom - bottom));
  545.             newbottom = (bottom + ((dir * len) * frac));
  546.             newbottom_z = (newbottom_z + KINDA_WANT);
  547.             if (!checkLanding ((newbottom - (FL_INWATER * v_forward))))
  548.             {
  549.                 return (FALSE);
  550.             }
  551.             NOTLAND = FALSE;
  552.         }
  553.         if (NOTLAND)
  554.         {
  555.             if (CheckLavaOrLow (newbottom))
  556.             {
  557.                 return (FALSE);
  558.             }
  559.         }
  560.         lnd = pointcontents (newbottom);
  561.         if ((lnd == CONTENT_WATER))
  562.         {
  563.             NOTLAND = FALSE;
  564.         }
  565.         bottom = newbottom;
  566.     }
  567.     jumpv_z = velz;
  568.     if (imagine)
  569.     {
  570.         if ((wlevel == FL_SWIM))
  571.         {
  572.             return (teleptest (45));
  573.         }
  574.         return (TRUE);
  575.     }
  576.     if ((wlevel == FL_SWIM))
  577.     {
  578.         return (Botwaterjump (jumpv));
  579.     }
  580.     if ((newbottom_z < (self.absmin_z - MAXJUMP)))
  581.     {
  582.         clearCache (self);
  583.     }
  584.     return (Botjump (jumpv));
  585. };
  586.  
  587. float (float dist) waterupdown =
  588. {
  589.     local float wlevel;
  590.     local float dis;
  591.     local float rnd;
  592.     local float zbottom;
  593.  
  594.     dis = KINDA_WANT;
  595.     wlevel = CheckWaterLevel ();
  596.     if ((wlevel < FL_SWIM))
  597.     {
  598.         return (FALSE);
  599.     }
  600.     if ((self.absmin_z > self.goalentity.origin_z))
  601.     {
  602.         if ((dis > KINDA_WANT))
  603.         {
  604.             dis = KINDA_WANT;
  605.         }
  606.         if (waterdownz (dis))
  607.         {
  608.             return (TRUE);
  609.         }
  610.         if (waterdownz ((dis * 0.5)))
  611.         {
  612.             return (TRUE);
  613.         }
  614.         if (waterdownz ((dis * 0.2)))
  615.         {
  616.             return (TRUE);
  617.         }
  618.     }
  619.     if ((wlevel == MOVETYPE_WALK))
  620.     {
  621.         if ((self.absmin_z < self.goalentity.origin_z))
  622.         {
  623.             dis = (self.goalentity.origin_z - self.absmin_z);
  624.             if ((dis > KINDA_WANT))
  625.             {
  626.                 dis = KINDA_WANT;
  627.             }
  628.             if (waterupz (dis))
  629.             {
  630.                 return (TRUE);
  631.             }
  632.             if (waterupz ((dis * 0.5)))
  633.             {
  634.                 return (TRUE);
  635.             }
  636.             if (waterupz ((dis * 0.2)))
  637.             {
  638.                 return (TRUE);
  639.             }
  640.         }
  641.     }
  642.     return (FALSE);
  643. };
  644.  
  645. void (float dist) strafemove =
  646. {
  647.     local float ofs;
  648.     local float rnd;
  649.  
  650.     if ((self.flags & FL_SWIM))
  651.     {
  652.         if (waterupdown (dist))
  653.         {
  654.             return;
  655.         }
  656.     }
  657.     ofs = 90;
  658.     rnd = random ();
  659.     if (self.enemy)
  660.     {
  661.         self.strafeonly = MOVETYPE_FLY;
  662.         if ((self.lefty & STRAFE_DIR))
  663.         {
  664.             ofs = (CONTENT_EMPTY * ofs);
  665.         }
  666.     }
  667.     else
  668.     {
  669.         if ((rnd < 0.5))
  670.         {
  671.             ofs = (CONTENT_EMPTY * ofs);
  672.         }
  673.     }
  674.     if (walkmove ((self.ideal_yaw + ofs), dist))
  675.     {
  676.         return;
  677.     }
  678.     if (self.enemy)
  679.     {
  680.         return;
  681.     }
  682.     ofs = (CONTENT_EMPTY * ofs);
  683.     if (walkmove ((self.ideal_yaw + ofs), dist))
  684.     {
  685.         return;
  686.     }
  687.     if ((self.flags & (FL_INWATER + FL_ONGROUND)))
  688.     {
  689.         self.search_time = (self.search_time - 0.3);
  690.     }
  691. };
  692.  
  693. void (float dist, float wlevel) BotUnderwaterMove =
  694. {
  695.     local float rng;
  696.     local float oldrng;
  697.     local float rnd;
  698.  
  699.     rnd = random ();
  700.     if ((rnd < 0.75))
  701.     {
  702.         oldrng = vlen ((self.origin - self.goalentity.origin));
  703.         movetogoal (dist);
  704.         rng = vlen ((self.origin - self.goalentity.origin));
  705.         if ((oldrng > rng))
  706.         {
  707.             return;
  708.         }
  709.         if ((wlevel == FL_SWIM))
  710.         {
  711.             if (Bot_tryjump (200, dist, FALSE))
  712.             {
  713.                 return;
  714.             }
  715.         }
  716.     }
  717.     strafemove (dist);
  718. };
  719.  
  720. float (float dist) trysidestep =
  721. {
  722.     local vector dir;
  723.     local vector start;
  724.  
  725.     dir = (self.goalentity.origin - self.origin);
  726.     dir_z = FALSE;
  727.     dir = normalize (dir);
  728.     start = self.origin;
  729.     start_z = (self.origin_z + (self.view_ofs_z * 0.5));
  730.     traceline (start, (start + (BOTSPEED * dir)), FALSE, self);
  731.     if ((trace_fraction != TRUE))
  732.     {
  733.         strafemove ((dist * 0.6));
  734.         return (TRUE);
  735.     }
  736.     makevectors (self.angles);
  737.     start = (start + (v_right * 15));
  738.     traceline (start, (start + (BOTSPEED * dir)), FALSE, self);
  739.     if ((trace_fraction != TRUE))
  740.     {
  741.         if (walkmove ((self.ideal_yaw - 90), (dist * 0.6)))
  742.         {
  743.             return (TRUE);
  744.         }
  745.     }
  746.     start = (start - (v_right * SVC_INTERMISSION));
  747.     traceline (start, (start + (BOTSPEED * dir)), FALSE, self);
  748.     if ((trace_fraction != TRUE))
  749.     {
  750.         if (walkmove ((self.ideal_yaw + 90), (dist * 0.6)))
  751.         {
  752.             return (TRUE);
  753.         }
  754.     }
  755.     return (FALSE);
  756. };
  757.  
  758. float (float dist) testmove =
  759. {
  760.     local float rng;
  761.     local float oldrng;
  762.  
  763.     oldrng = vlen ((self.origin - self.goalentity.origin));
  764.     movetogoal (dist);
  765.     rng = vlen ((self.origin - self.goalentity.origin));
  766.     if ((rng < oldrng))
  767.     {
  768.         return (TRUE);
  769.     }
  770.     return (FALSE);
  771. };
  772.  
  773. void (float dist) BotmovetoWindTunnel =
  774. {
  775.     if (testmove (dist))
  776.     {
  777.         return;
  778.     }
  779.     if (trysidestep (dist))
  780.     {
  781.         return;
  782.     }
  783.     if (Bot_tryjump (270, dist, FALSE))
  784.     {
  785.         return;
  786.     }
  787.     strafemove ((dist * 0.5));
  788.     return;
  789. };
  790.  
  791. void (float dist) BotmovetoVisiblegoal =
  792. {
  793.     if (walkmove (self.ideal_yaw, FL_CLIENT))
  794.     {
  795.         botwalkmove (self.ideal_yaw, (dist - FL_CLIENT));
  796.         return;
  797.     }
  798.     if (walkmove ((self.ideal_yaw + 45), FL_CLIENT))
  799.     {
  800.         movetogoal ((dist - FL_CLIENT));
  801.         return;
  802.     }
  803.     if (walkmove ((self.ideal_yaw - 45), FL_CLIENT))
  804.     {
  805.         movetogoal ((dist - FL_CLIENT));
  806.         return;
  807.     }
  808.     if (trysidestep (dist))
  809.     {
  810.         return;
  811.     }
  812.     if (Bot_tryjump (270, dist, FALSE))
  813.     {
  814.         return;
  815.     }
  816.     strafemove ((dist * 0.5));
  817.     return;
  818. };
  819.  
  820. void (float dist) Botmovetogoal =
  821. {
  822.     local entity Botgoal;
  823.     local float wlevel;
  824.  
  825.     self.oldorigin = self.origin;
  826.     Botgoal = self.goalentity;
  827.     self.ideal_yaw = vectoyaw ((Botgoal.origin - self.origin));
  828.     ChangeYaw ();
  829.     if ((self.flags & FL_INWATER))
  830.     {
  831.         wlevel = CheckWaterLevel ();
  832.         if ((wlevel > TRUE))
  833.         {
  834.             BotUnderwaterMove ((dist * 0.8), wlevel);
  835.             return;
  836.         }
  837.     }
  838.     if ((Botgoal.goalentity.classname == "trigger_push"))
  839.     {
  840.         BotmovetoWindTunnel (dist);
  841.         return;
  842.     }
  843.     if (Spotvisible (Botgoal))
  844.     {
  845.         BotmovetoVisiblegoal (dist);
  846.         return;
  847.     }
  848.     if (testmove (dist))
  849.     {
  850.         return;
  851.     }
  852.     strafemove ((dist * 0.8));
  853.     return;
  854. };
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!