home *** CD-ROM | disk | FTP | other *** search
/ Gambler 19 / GAMBLERCD19.BIN / UTILS / 3D / BRONIE / DUAL_LAU.ZIP / src / g_monster.c < prev    next >
C/C++ Source or Header  |  1998-01-13  |  17KB  |  718 lines
  1. #include "g_local.h"
  2.  
  3.  
  4. //
  5. // monster weapons
  6. //
  7.  
  8. //FIXME mosnters should call these with a totally accurate direction
  9. // and we can mess it up based on skill.  Spread should be for normal
  10. // and we can tighten or loosen based on skill.  We could muck with
  11. // the damages too, but I'm not sure that's such a good idea.
  12. void monster_fire_bullet (edict_t *self, vec3_t start, vec3_t dir, int damage, int kick, int hspread, int vspread, int flashtype)
  13. {
  14.     fire_bullet (self, start, dir, damage, kick, hspread, vspread);
  15.  
  16.     gi.WriteByte (svc_muzzleflash2);
  17.     gi.WriteShort (self - g_edicts);
  18.     gi.WriteByte (flashtype);
  19.     gi.multicast (start, MULTICAST_PVS);
  20. }
  21.  
  22. void monster_fire_shotgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int hspread, int vspread, int count, int flashtype)
  23. {
  24.     fire_shotgun (self, start, aimdir, damage, kick, hspread, vspread, count);
  25.  
  26.     gi.WriteByte (svc_muzzleflash2);
  27.     gi.WriteShort (self - g_edicts);
  28.     gi.WriteByte (flashtype);
  29.     gi.multicast (start, MULTICAST_PVS);
  30. }
  31.  
  32. void monster_fire_blaster (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype, int effect)
  33. {
  34.     fire_blaster (self, start, dir, damage, speed, effect);
  35.  
  36.     gi.WriteByte (svc_muzzleflash2);
  37.     gi.WriteShort (self - g_edicts);
  38.     gi.WriteByte (flashtype);
  39.     gi.multicast (start, MULTICAST_PVS);
  40. }    
  41.  
  42. void monster_fire_grenade (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int flashtype)
  43. {
  44.     //Patch
  45.     //fire_grenade (self, start, aimdir, damage, speed, 2.5, damage+40);
  46.     fire_grenade (self, start, aimdir, damage, speed, 2.5, damage+40,0);
  47.     gi.WriteByte (svc_muzzleflash2);
  48.     gi.WriteShort (self - g_edicts);
  49.     gi.WriteByte (flashtype);
  50.     gi.multicast (start, MULTICAST_PVS);
  51. }
  52.  
  53. void monster_fire_rocket (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype)
  54. {
  55.     fire_rocket (self, start, dir, damage, speed, damage+20, damage);
  56.  
  57.     gi.WriteByte (svc_muzzleflash2);
  58.     gi.WriteShort (self - g_edicts);
  59.     gi.WriteByte (flashtype);
  60.     gi.multicast (start, MULTICAST_PVS);
  61. }    
  62.  
  63. void monster_fire_railgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int flashtype)
  64. {
  65.     fire_rail (self, start, aimdir, damage, kick);
  66.  
  67.     gi.WriteByte (svc_muzzleflash2);
  68.     gi.WriteShort (self - g_edicts);
  69.     gi.WriteByte (flashtype);
  70.     gi.multicast (start, MULTICAST_PVS);
  71. }
  72.  
  73. void monster_fire_bfg (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int kick, float damage_radius, int flashtype)
  74. {
  75.     fire_bfg (self, start, aimdir, damage, speed, damage_radius);
  76.  
  77.     gi.WriteByte (svc_muzzleflash2);
  78.     gi.WriteShort (self - g_edicts);
  79.     gi.WriteByte (flashtype);
  80.     gi.multicast (start, MULTICAST_PVS);
  81. }
  82.  
  83.  
  84.  
  85. //
  86. // Monster utility functions
  87. //
  88.  
  89. static void M_FliesOff (edict_t *self)
  90. {
  91.     self->s.effects &= ~EF_FLIES;
  92.     self->s.sound = 0;
  93. }
  94.  
  95. static void M_FliesOn (edict_t *self)
  96. {
  97.     self->s.effects |= EF_FLIES;
  98.     self->s.sound = gi.soundindex ("infantry/inflies1.wav");
  99.     self->think = M_FliesOff;
  100.     self->nextthink = level.time + 60;
  101. }
  102.  
  103. void M_FlyCheck (edict_t *self)
  104. {
  105.     if (self->waterlevel)
  106.         return;
  107.  
  108.     if (random() > 0.5)
  109.         return;
  110.  
  111.     self->think = M_FliesOn;
  112.     self->nextthink = level.time + 5 + 10 * random();
  113. }
  114.  
  115. void AttackFinished (edict_t *self, float time)
  116. {
  117.     self->monsterinfo.attack_finished = level.time + time;
  118. }
  119.  
  120.  
  121. void M_CheckGround (edict_t *ent)
  122. {
  123.     vec3_t        point;
  124.     trace_t        trace;
  125.  
  126.     if (ent->flags & (FL_SWIM|FL_FLY))
  127.         return;
  128.  
  129.     if (ent->velocity[2] > 100)
  130.     {
  131.         ent->groundentity = NULL;
  132.         return;
  133.     }
  134.  
  135. // if the hull point one-quarter unit down is solid the entity is on ground
  136.     point[0] = ent->s.origin[0];
  137.     point[1] = ent->s.origin[1];
  138.     point[2] = ent->s.origin[2] - 0.25;
  139.  
  140.     trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, point, ent, MASK_MONSTERSOLID);
  141.  
  142.     // check steepness
  143.     if ( trace.plane.normal[2] < 0.7 && !trace.startsolid)
  144.     {
  145.         ent->groundentity = NULL;
  146.         return;
  147.     }
  148.  
  149. //    ent->groundentity = trace.ent;
  150. //    ent->groundentity_linkcount = trace.ent->linkcount;
  151. //    if (!trace.startsolid && !trace.allsolid)
  152. //        VectorCopy (trace.endpos, ent->s.origin);
  153.     if (!trace.startsolid && !trace.allsolid)
  154.     {
  155.         VectorCopy (trace.endpos, ent->s.origin);
  156.         ent->groundentity = trace.ent;
  157.         ent->groundentity_linkcount = trace.ent->linkcount;
  158.         ent->velocity[2] = 0;
  159.     }
  160. }
  161.  
  162.  
  163. void M_CatagorizePosition (edict_t *ent)
  164. {
  165.     vec3_t        point;
  166.     int            cont;
  167.  
  168. //
  169. // get waterlevel
  170. //
  171.     point[0] = ent->s.origin[0];
  172.     point[1] = ent->s.origin[1];
  173.     point[2] = ent->s.origin[2] + ent->mins[2] + 1;    
  174.     cont = gi.pointcontents (point);
  175.  
  176.     if (!(cont & MASK_WATER))
  177.     {
  178.         ent->waterlevel = 0;
  179.         ent->watertype = 0;
  180.         return;
  181.     }
  182.  
  183.     ent->watertype = cont;
  184.     ent->waterlevel = 1;
  185.     point[2] += 26;
  186.     cont = gi.pointcontents (point);
  187.     if (!(cont & MASK_WATER))
  188.         return;
  189.  
  190.     ent->waterlevel = 2;
  191.     point[2] += 22;
  192.     cont = gi.pointcontents (point);
  193.     if (cont & MASK_WATER)
  194.         ent->waterlevel = 3;
  195. }
  196.  
  197.  
  198. void M_WorldEffects (edict_t *ent)
  199. {
  200.     int        dmg;
  201.  
  202.     if (ent->health > 0)
  203.     {
  204.         if (!(ent->flags & FL_SWIM))
  205.         {
  206.             if (ent->waterlevel < 3)
  207.             {
  208.                 ent->air_finished = level.time + 12;
  209.             }
  210.             else if (ent->air_finished < level.time)
  211.             {    // drown!
  212.                 if (ent->pain_debounce_time < level.time)
  213.                 {
  214.                     dmg = 2 + 2 * floor(level.time - ent->air_finished);
  215.                     if (dmg > 15)
  216.                         dmg = 15;
  217.                     T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, dmg, 0, DAMAGE_NO_ARMOR);
  218.                     ent->pain_debounce_time = level.time + 1;
  219.                 }
  220.             }
  221.         }
  222.         else
  223.         {
  224.             if (ent->waterlevel > 0)
  225.             {
  226.                 ent->air_finished = level.time + 9;
  227.             }
  228.             else if (ent->air_finished < level.time)
  229.             {    // suffocate!
  230.                 if (ent->pain_debounce_time < level.time)
  231.                 {
  232.                     dmg = 2 + 2 * floor(level.time - ent->air_finished);
  233.                     if (dmg > 15)
  234.                         dmg = 15;
  235.                     T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, dmg, 0, DAMAGE_NO_ARMOR);
  236.                     ent->pain_debounce_time = level.time + 1;
  237.                 }
  238.             }
  239.         }
  240.     }
  241.     
  242.     if (ent->waterlevel == 0)
  243.     {
  244.         if (ent->flags & FL_INWATER)
  245.         {    
  246.             gi.sound (ent, CHAN_BODY, gi.soundindex("player/watr_out.wav"), 1, ATTN_NORM, 0);
  247.             ent->flags &= ~FL_INWATER;
  248.         }
  249.         return;
  250.     }
  251.  
  252.     if ((ent->watertype & CONTENTS_LAVA) && !(ent->flags & FL_IMMUNE_LAVA))
  253.     {
  254.         if (ent->damage_debounce_time < level.time)
  255.         {
  256.             ent->damage_debounce_time = level.time + 0.2;
  257.             T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, 10*ent->waterlevel, 0, 0);
  258.         }
  259.     }
  260.     if ((ent->watertype & CONTENTS_SLIME) && !(ent->flags & FL_IMMUNE_SLIME))
  261.     {
  262.         if (ent->damage_debounce_time < level.time)
  263.         {
  264.             ent->damage_debounce_time = level.time + 1;
  265.             T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, 4*ent->waterlevel, 0, 0);
  266.         }
  267.     }
  268.     
  269.     if ( !(ent->flags & FL_INWATER) )
  270.     {    
  271.         if (ent->watertype & CONTENTS_LAVA)
  272.             if (random() <= 0.5)
  273.                 gi.sound (ent, CHAN_BODY, gi.soundindex("player/lava1.wav"), 1, ATTN_NORM, 0);
  274.             else
  275.                 gi.sound (ent, CHAN_BODY, gi.soundindex("player/lava2.wav"), 1, ATTN_NORM, 0);
  276.         else if (ent->watertype & CONTENTS_SLIME)
  277.             gi.sound (ent, CHAN_BODY, gi.soundindex("player/watr_in.wav"), 1, ATTN_NORM, 0);
  278.         else if (ent->watertype & CONTENTS_WATER)
  279.             gi.sound (ent, CHAN_BODY, gi.soundindex("player/watr_in.wav"), 1, ATTN_NORM, 0);
  280.  
  281.         ent->flags |= FL_INWATER;
  282.         ent->damage_debounce_time = 0;
  283.     }
  284. }
  285.  
  286.  
  287. void M_droptofloor (edict_t *ent)
  288. {
  289.     vec3_t        end;
  290.     trace_t        trace;
  291.  
  292.     ent->s.origin[2] += 1;
  293.     VectorCopy (ent->s.origin, end);
  294.     end[2] -= 256;
  295.     
  296.     trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, end, ent, MASK_MONSTERSOLID);
  297.  
  298.     if (trace.fraction == 1 || trace.allsolid)
  299.         return;
  300.  
  301.     VectorCopy (trace.endpos, ent->s.origin);
  302.  
  303.     gi.linkentity (ent);
  304.     M_CheckGround (ent);
  305.     M_CatagorizePosition (ent);
  306. }
  307.  
  308.  
  309. void M_SetEffects (edict_t *ent)
  310. {
  311.     ent->s.effects &= ~(EF_COLOR_SHELL|EF_POWERSCREEN);
  312.     ent->s.renderfx &= ~(RF_SHELL_RED|RF_SHELL_GREEN|RF_SHELL_BLUE);
  313.  
  314.     if (ent->monsterinfo.aiflags & AI_RESURRECTING)
  315.     {
  316.         ent->s.effects |= EF_COLOR_SHELL;
  317.         ent->s.renderfx |= RF_SHELL_RED;
  318.     }
  319.  
  320.     if (ent->health <= 0)
  321.         return;
  322.  
  323.     if (ent->powerarmor_time > level.time)
  324.     {
  325.         if (ent->monsterinfo.power_armor_type == POWER_ARMOR_SCREEN)
  326.         {
  327.             ent->s.effects |= EF_POWERSCREEN;
  328.         }
  329.         else if (ent->monsterinfo.power_armor_type == POWER_ARMOR_SHIELD)
  330.         {
  331.             ent->s.effects |= EF_COLOR_SHELL;
  332.             ent->s.renderfx |= RF_SHELL_GREEN;
  333.         }
  334.     }
  335. }
  336.  
  337.  
  338. void M_MoveFrame (edict_t *self)
  339. {
  340.     mmove_t    *move;
  341.     int        index;
  342.  
  343.     move = self->monsterinfo.currentmove;
  344.     self->nextthink = level.time + FRAMETIME;
  345.  
  346.     if ((self->monsterinfo.nextframe) && (self->monsterinfo.nextframe >= move->firstframe) && (self->monsterinfo.nextframe <= move->lastframe))
  347.     {
  348.         self->s.frame = self->monsterinfo.nextframe;
  349.         self->monsterinfo.nextframe = 0;
  350.     }
  351.     else
  352.     {
  353.         if (self->s.frame == move->lastframe)
  354.         {
  355.             if (move->endfunc)
  356.             {
  357.                 move->endfunc (self);
  358.  
  359.                 // regrab move, endfunc is very likely to change it
  360.                 move = self->monsterinfo.currentmove;
  361.  
  362.                 // check for death
  363.                 if (self->svflags & SVF_DEADMONSTER)
  364.                     return;
  365.             }
  366.         }
  367.  
  368.         if (self->s.frame < move->firstframe || self->s.frame > move->lastframe)
  369.         {
  370.             self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
  371.             self->s.frame = move->firstframe;
  372.         }
  373.         else
  374.         {
  375.             if (!(self->monsterinfo.aiflags & AI_HOLD_FRAME))
  376.             {
  377.                 self->s.frame++;
  378.                 if (self->s.frame > move->lastframe)
  379.                     self->s.frame = move->firstframe;
  380.             }
  381.         }
  382.     }
  383.  
  384.     index = self->s.frame - move->firstframe;
  385.     if (move->frame[index].aifunc)
  386.         if (!(self->monsterinfo.aiflags & AI_HOLD_FRAME))
  387.             move->frame[index].aifunc (self, move->frame[index].dist * self->monsterinfo.scale);
  388.         else
  389.             move->frame[index].aifunc (self, 0);
  390.  
  391.     if (move->frame[index].thinkfunc)
  392.         move->frame[index].thinkfunc (self);
  393. }
  394.  
  395.  
  396. void monster_think (edict_t *self)
  397. {
  398.     M_MoveFrame (self);
  399.     if (self->linkcount != self->monsterinfo.linkcount)
  400.     {
  401.         self->monsterinfo.linkcount = self->linkcount;
  402.         M_CheckGround (self);
  403.     }
  404.     M_CatagorizePosition (self);
  405.     M_WorldEffects (self);
  406.     M_SetEffects (self);
  407. }
  408.  
  409.  
  410. /*
  411. ================
  412. monster_use
  413.  
  414. Using a monster makes it angry at the current activator
  415. ================
  416. */
  417. void monster_use (edict_t *self, edict_t *other, edict_t *activator)
  418. {
  419.     if (self->enemy)
  420.         return;
  421.     if (self->health <= 0)
  422.         return;
  423.     if (activator->flags & FL_NOTARGET)
  424.         return;
  425.     if (!(activator->client) && !(activator->monsterinfo.aiflags & AI_GOOD_GUY))
  426.         return;
  427.     
  428. // delay reaction so if the monster is teleported, its sound is still heard
  429.     self->enemy = activator;
  430.     FoundTarget (self);
  431. }
  432.  
  433.  
  434. void monster_start_go (edict_t *self);
  435.  
  436.  
  437. void monster_triggered_spawn (edict_t *self)
  438. {
  439.     self->s.origin[2] += 1;
  440.     KillBox (self);
  441.  
  442.     self->solid = SOLID_BBOX;
  443.     self->movetype = MOVETYPE_STEP;
  444.     self->svflags &= ~SVF_NOCLIENT;
  445.     self->air_finished = level.time + 12;
  446.     gi.linkentity (self);
  447.  
  448.     monster_start_go (self);
  449.  
  450.     if (self->enemy && !(self->spawnflags & 1) && !(self->enemy->flags & FL_NOTARGET))
  451.     {
  452.         FoundTarget (self);
  453.     }
  454.     else
  455.     {
  456.         self->enemy = NULL;
  457.     }
  458. }
  459.  
  460. void monster_triggered_spawn_use (edict_t *self, edict_t *other, edict_t *activator)
  461. {
  462.     // we have a one frame delay here so we don't telefrag the guy who activated us
  463.     self->think = monster_triggered_spawn;
  464.     self->nextthink = level.time + FRAMETIME;
  465.     if (activator->client)
  466.         self->enemy = activator;
  467.     self->use = monster_use;
  468. }
  469.  
  470. void monster_triggered_start (edict_t *self)
  471. {
  472.     self->solid = SOLID_NOT;
  473.     self->movetype = MOVETYPE_NONE;
  474.     self->svflags |= SVF_NOCLIENT;
  475.     self->nextthink = 0;
  476.     self->use = monster_triggered_spawn_use;
  477. }
  478.  
  479.  
  480. /*
  481. ================
  482. monster_death_use
  483.  
  484. When a monster dies, it fires all of its targets with the current
  485. enemy as activator.
  486. ================
  487. */
  488. void monster_death_use (edict_t *self)
  489. {
  490.     self->flags &= ~(FL_FLY|FL_SWIM);
  491.     self->monsterinfo.aiflags &= AI_GOOD_GUY;
  492.  
  493.     if (self->item)
  494.     {
  495.         Drop_Item (self, self->item);
  496.         self->item = NULL;
  497.     }
  498.  
  499.     if (self->deathtarget)
  500.         self->target = self->deathtarget;
  501.  
  502.     if (!self->target)
  503.         return;
  504.  
  505.     G_UseTargets (self, self->enemy);
  506. }
  507.  
  508.  
  509. //============================================================================
  510.  
  511. qboolean monster_start (edict_t *self)
  512. {
  513.     if (deathmatch->value || nomonsters->value)
  514.     {
  515.         G_FreeEdict (self);
  516.         return false;
  517.     }
  518.  
  519.     if ((self->spawnflags & 4) && !(self->monsterinfo.aiflags & AI_GOOD_GUY))
  520.     {
  521.         self->spawnflags &= ~4;
  522.         self->spawnflags |= 1;
  523. //        gi.dprintf("fixed spawnflags on %s at %s\n", self->classname, vtos(self->s.origin));
  524.     }
  525.  
  526.     if (!(self->monsterinfo.aiflags & AI_GOOD_GUY))
  527.         level.total_monsters++;
  528.  
  529.     self->nextthink = level.time + FRAMETIME;
  530.     self->svflags |= SVF_MONSTER;
  531.     self->s.renderfx |= RF_FRAMELERP;
  532.     self->takedamage = DAMAGE_AIM;
  533.     self->air_finished = level.time + 12;
  534.     self->use = monster_use;
  535.     self->max_health = self->health;
  536.     self->clipmask = MASK_MONSTERSOLID;
  537.  
  538.     self->s.skinnum = 0;
  539.     self->deadflag = DEAD_NO;
  540.     self->svflags &= ~SVF_DEADMONSTER;
  541.  
  542.     if (!self->monsterinfo.checkattack)
  543.         self->monsterinfo.checkattack = M_CheckAttack;
  544.     VectorCopy (self->s.origin, self->s.old_origin);
  545.  
  546.     if (st.item)
  547.     {
  548.         self->item = FindItemByClassname (st.item);
  549.         if (!self->item)
  550.             gi.dprintf("%s at %s has bad item: %s\n", self->classname, vtos(self->s.origin), st.item);
  551.     }
  552.  
  553.     // randomize what frame they start on
  554.     if (self->monsterinfo.currentmove)
  555.         self->s.frame = self->monsterinfo.currentmove->firstframe + (rand() % (self->monsterinfo.currentmove->lastframe - self->monsterinfo.currentmove->firstframe + 1));
  556.  
  557.     return true;
  558. }
  559.  
  560. void monster_start_go (edict_t *self)
  561. {
  562.     vec3_t    v;
  563.  
  564.     if (self->health <= 0)
  565.         return;
  566.  
  567.     // check for target to combat_point and change to combattarget
  568.     if (self->target)
  569.     {
  570.         qboolean    notcombat;
  571.         qboolean    fixup;
  572.         edict_t        *target;
  573.  
  574.         target = NULL;
  575.         notcombat = false;
  576.         fixup = false;
  577.         while ((target = G_Find (target, FOFS(targetname), self->target)) != NULL)
  578.         {
  579.             if (strcmp(target->classname, "point_combat") == 0)
  580.             {
  581.                 self->combattarget = self->target;
  582.                 fixup = true;
  583.             }
  584.             else
  585.             {
  586.                 notcombat = true;
  587.             }
  588.         }
  589.         if (notcombat && self->combattarget)
  590.             gi.dprintf("%s at %s has target with mixed types\n", self->classname, vtos(self->s.origin));
  591.         if (fixup)
  592.             self->target = NULL;
  593.     }
  594.  
  595.     // validate combattarget
  596.     if (self->combattarget)
  597.     {
  598.         edict_t        *target;
  599.  
  600.         target = NULL;
  601.         while ((target = G_Find (target, FOFS(targetname), self->combattarget)) != NULL)
  602.         {
  603.             if (strcmp(target->classname, "point_combat") != 0)
  604.             {
  605.                 gi.dprintf("%s at (%i %i %i) has a bad combattarget %s : %s at (%i %i %i)\n",
  606.                     self->classname, (int)self->s.origin[0], (int)self->s.origin[1], (int)self->s.origin[2],
  607.                     self->combattarget, target->classname, (int)target->s.origin[0], (int)target->s.origin[1],
  608.                     (int)target->s.origin[2]);
  609.             }
  610.         }
  611.     }
  612.  
  613.     if (self->target)
  614.     {
  615.         self->goalentity = self->movetarget = G_PickTarget(self->target);
  616.         if (!self->movetarget)
  617.         {
  618.             gi.dprintf ("%s can't find target %s at %s\n", self->classname, self->target, vtos(self->s.origin));
  619.             self->target = NULL;
  620.             self->monsterinfo.pausetime = 100000000;
  621.             self->monsterinfo.stand (self);
  622.         }
  623.         else if (strcmp (self->movetarget->classname, "path_corner") == 0)
  624.         {
  625.             VectorSubtract (self->goalentity->s.origin, self->s.origin, v);
  626.             self->ideal_yaw = self->s.angles[YAW] = vectoyaw(v);
  627.             self->monsterinfo.walk (self);
  628.             self->target = NULL;
  629.         }
  630.         else
  631.         {
  632.             self->goalentity = self->movetarget = NULL;
  633.             self->monsterinfo.pausetime = 100000000;
  634.             self->monsterinfo.stand (self);
  635.         }
  636.     }
  637.     else
  638.     {
  639.         self->monsterinfo.pausetime = 100000000;
  640.         self->monsterinfo.stand (self);
  641.     }
  642.  
  643.     self->think = monster_think;
  644.     self->nextthink = level.time + FRAMETIME;
  645. }
  646.  
  647.  
  648. void walkmonster_start_go (edict_t *self)
  649. {
  650.     if (!(self->spawnflags & 2) && level.time < 1)
  651.     {
  652.         M_droptofloor (self);
  653.  
  654.         if (self->groundentity)
  655.             if (!M_walkmove (self, 0, 0))
  656.                 gi.dprintf ("%s in solid at %s\n", self->classname, vtos(self->s.origin));
  657.     }
  658.     
  659.     if (!self->yaw_speed)
  660.         self->yaw_speed = 20;
  661.     self->viewheight = 25;
  662.  
  663.     monster_start_go (self);
  664.  
  665.     if (self->spawnflags & 2)
  666.         monster_triggered_start (self);
  667. }
  668.  
  669. void walkmonster_start (edict_t *self)
  670. {
  671.     self->think = walkmonster_start_go;
  672.     monster_start (self);
  673. }
  674.  
  675.  
  676. void flymonster_start_go (edict_t *self)
  677. {
  678.     if (!M_walkmove (self, 0, 0))
  679.         gi.dprintf ("%s in solid at %s\n", self->classname, vtos(self->s.origin));
  680.  
  681.     if (!self->yaw_speed)
  682.         self->yaw_speed = 10;
  683.     self->viewheight = 25;
  684.  
  685.     monster_start_go (self);
  686.  
  687.     if (self->spawnflags & 2)
  688.         monster_triggered_start (self);
  689. }
  690.  
  691.  
  692. void flymonster_start (edict_t *self)
  693. {
  694.     self->flags |= FL_FLY;
  695.     self->think = flymonster_start_go;
  696.     monster_start (self);
  697. }
  698.  
  699.  
  700. void swimmonster_start_go (edict_t *self)
  701. {
  702.     if (!self->yaw_speed)
  703.         self->yaw_speed = 10;
  704.     self->viewheight = 10;
  705.  
  706.     monster_start_go (self);
  707.  
  708.     if (self->spawnflags & 2)
  709.         monster_triggered_start (self);
  710. }
  711.  
  712. void swimmonster_start (edict_t *self)
  713. {
  714.     self->flags |= FL_SWIM;
  715.     self->think = swimmonster_start_go;
  716.     monster_start (self);
  717. }
  718.