qcsrc/common/monsters/sv_monsters.qc

   1 // =========================
   2 //  SVQC Monster Properties
   3 // =========================
   4
   5
   6 void M_Item_Touch ()
   7 {
   8         if(self && IS_PLAYER(other) && other.deadflag == DEAD_NO)
   9         {
  10                 Item_Touch();
  11                 self.think = SUB_Remove;
  12                 self.nextthink = time + 0.1;
  13         }
  14 }
  15
  16 void monster_item_spawn()
  17 {
  18         if(self.monster_loot)
  19                 self.monster_loot();
  20
  21         self.gravity = 1;
  22         self.velocity = randomvec() * 175 + '0 0 325';
  23         self.touch = M_Item_Touch;
  24
  25         SUB_SetFade(self, time + autocvar_g_monsters_drop_time, 1);
  26 }
  27
  28 void monster_dropitem()
  29 {
  30         if(!self.candrop || !self.monster_loot)
  31                 return;
  32
  33         vector org = self.origin + ((self.mins + self.maxs) * 0.5);
  34         entity e = spawn();
  35
  36         setorigin(e, org);
  37
  38         e.monster_loot = self.monster_loot;
  39
  40         other = e;
  41         MUTATOR_CALLHOOK(MonsterDropItem);
  42         e = other;
  43
  44         e.think = monster_item_spawn;
  45         e.nextthink = time + 0.3;
  46 }
  47
  48 void monsters_setframe(float _frame)
  49 {
  50         if(self.frame == _frame)
  51                 return;
  52
  53         self.anim_start_time = time;
  54         self.frame = _frame;
  55         self.SendFlags |= MSF_ANIM;
  56 }
  57
  58 float monster_isvalidtarget (entity targ, entity ent)
  59 {
  60         if(!targ || !ent)
  61                 return FALSE; // someone doesn't exist
  62
  63         if(time < game_starttime)
  64                 return FALSE; // monsters do nothing before the match has started
  65
  66         WarpZone_TraceLine(ent.origin, targ.origin, MOVE_NORMAL, ent);
  67
  68         if(vlen(targ.origin - ent.origin) >= ent.target_range)
  69                 return FALSE; // enemy is too far away
  70
  71         if not(targ.vehicle_flags & VHF_ISVEHICLE)
  72         if(trace_ent != targ)
  73                 return FALSE; // we can't see the enemy
  74
  75         if(targ.takedamage == DAMAGE_NO)
  76                 return FALSE; // enemy can't be damaged
  77
  78         if(targ.items & IT_INVISIBILITY)
  79                 return FALSE; // enemy is invisible
  80
  81         if(substring(targ.classname, 0, 10) == "onslaught_")
  82                 return FALSE; // don't attack onslaught targets
  83
  84         if(IS_SPEC(targ) || IS_OBSERVER(targ))
  85                 return FALSE; // enemy is a spectator
  86
  87         if not(targ.vehicle_flags & VHF_ISVEHICLE) // vehicles dont count as alive?
  88         if(targ.deadflag != DEAD_NO || ent.deadflag != DEAD_NO || targ.health <= 0 || ent.health <= 0)
  89                 return FALSE; // enemy/self is dead
  90
  91         if(ent.monster_owner == targ)
  92                 return FALSE; // don't attack our master
  93
  94         if(targ.monster_owner == ent)
  95                 return FALSE; // don't attack our pet
  96
  97         if not(targ.vehicle_flags & VHF_ISVEHICLE)
  98         if(targ.flags & FL_NOTARGET)
  99                 return FALSE; // enemy can't be targeted
 100
 101         if not(autocvar_g_monsters_typefrag)
 102         if(targ.BUTTON_CHAT)
 103                 return FALSE; // no typefragging!
 104
 105         if not(IsDifferentTeam(targ, ent))
 106                 return FALSE; // enemy is on our team
 107
 108         if(autocvar_g_monsters_target_infront)
 109         if(ent.enemy != targ)
 110         {
 111                 float dot;
 112
 113                 makevectors (ent.angles);
 114                 dot = normalize (targ.origin - ent.origin) * v_forward;
 115
 116                 if(dot <= 0.3)
 117                         return FALSE;
 118         }
 119
 120         return TRUE;
 121 }
 122
 123 entity FindTarget (entity ent)
 124 {
 125         if(MUTATOR_CALLHOOK(MonsterFindTarget)) { return ent.enemy; } // Handled by a mutator
 126         entity e;
 127
 128         for(e = world; (e = findflags(e, monster_attack, TRUE)); )
 129         if(monster_isvalidtarget(e, ent))
 130                 return e;
 131
 132         return world;
 133 }
 134
 135 void MonsterTouch ()
 136 {
 137         if(other == world)
 138                 return;
 139
 140         if(self.enemy != other)
 141         if not(other.flags & FL_MONSTER)
 142         if(monster_isvalidtarget(other, self))
 143                 self.enemy = other;
 144 }
 145
 146 void monster_sound(string msound, float sound_delay, float delaytoo)
 147 {
 148         if(delaytoo && time < self.msound_delay)
 149                 return; // too early
 150
 151         if(msound == "")
 152                 return; // sound doesn't exist
 153
 154         sound(self, CHAN_AUTO, msound, VOL_BASE, ATTN_NORM);
 155
 156         self.msound_delay = time + sound_delay;
 157 }
 158
 159 void monster_precachesounds(entity e)
 160 {
 161         precache_sound(e.msound_idle);
 162         precache_sound(e.msound_death);
 163         precache_sound(e.msound_attack_melee);
 164         precache_sound(e.msound_attack_ranged);
 165         precache_sound(e.msound_sight);
 166         precache_sound(e.msound_pain);
 167 }
 168
 169 void monster_setupsounds(string mon)
 170 {
 171         if(self.msound_idle == "") self.msound_idle = strzone(strcat("monsters/", mon, "_idle.wav"));
 172         if(self.msound_death == "") self.msound_death = strzone(strcat("monsters/", mon, "_death.wav"));
 173         if(self.msound_pain == "") self.msound_pain = strzone(strcat("monsters/", mon, "_pain.wav"));
 174         if(self.msound_attack_melee == "") self.msound_attack_melee = strzone(strcat("monsters/", mon, "_melee.wav"));
 175         if(self.msound_attack_ranged == "") self.msound_attack_ranged = strzone(strcat("monsters/", mon, "_attack.wav"));
 176         if(self.msound_sight == "") self.msound_sight = strzone(strcat("monsters/", mon, "_sight.wav"));
 177 }
 178
 179 void monster_makevectors(entity e)
 180 {
 181         vector v;
 182
 183         v = CENTER_OR_VIEWOFS(e);
 184         self.v_angle = vectoangles(v - (self.origin + self.view_ofs));
 185         self.v_angle_x = -self.v_angle_x;
 186
 187         makevectors(self.v_angle);
 188 }
 189
 190 float monster_melee(entity targ, float damg, float er, float deathtype, float dostop)
 191 {
 192         float rdmg = damg * random();
 193
 194         if (self.health <= 0)
 195                 return FALSE;
 196         if (targ == world)
 197                 return FALSE;
 198
 199         if(dostop)
 200         {
 201                 self.velocity_x = 0;
 202                 self.velocity_y = 0;
 203                 self.state = MONSTER_STATE_ATTACK_MELEE;
 204                 self.SendFlags |= MSF_MOVE;
 205         }
 206
 207         monster_makevectors(targ);
 208
 209         traceline(self.origin + self.view_ofs, self.origin + v_forward * er, 0, self);
 210
 211         if(trace_ent.takedamage)
 212                 Damage(targ, self, self, rdmg * monster_skill, deathtype, targ.origin, normalize(targ.origin - self.origin));
 213
 214         return TRUE;
 215 }
 216
 217 void Monster_CheckMinibossFlag ()
 218 {
 219         if(MUTATOR_CALLHOOK(MonsterCheckBossFlag))
 220                 return;
 221
 222         float chance = random() * 100;
 223
 224         // g_monsters_miniboss_chance cvar or spawnflags 64 causes a monster to be a miniboss
 225         if ((self.spawnflags & MONSTERFLAG_MINIBOSS) || (chance < autocvar_g_monsters_miniboss_chance))
 226         {
 227                 self.health += autocvar_g_monsters_miniboss_healthboost;
 228                 if not(self.weapon)
 229                         self.weapon = WEP_NEX;
 230         }
 231 }
 232
 233 float Monster_CanRespawn(entity ent)
 234 {
 235         other = ent;
 236         if(MUTATOR_CALLHOOK(MonsterRespawn))
 237                 return TRUE; // enabled by a mutator
 238
 239         if(ent.spawnflags & MONSTERFLAG_NORESPAWN)
 240                 return FALSE;
 241
 242         if not(autocvar_g_monsters_respawn)
 243                 return FALSE;
 244
 245         return TRUE;
 246 }
 247
 248 void Monster_Fade ()
 249 {
 250         if(Monster_CanRespawn(self))
 251         {
 252                 self.monster_respawned = TRUE;
 253                 self.think = self.monster_spawnfunc;
 254                 self.nextthink = time + self.respawntime;
 255                 self.deadflag = DEAD_RESPAWNING;
 256                 if(self.spawnflags & MONSTER_RESPAWN_DEATHPOINT)
 257                 {
 258                         self.pos1 = self.origin;
 259                         self.pos2 = self.angles;
 260                 }
 261                 self.event_damage = func_null;
 262                 self.takedamage = DAMAGE_NO;
 263                 setorigin(self, self.pos1);
 264                 self.angles = self.pos2;
 265                 self.health = self.max_health; // TODO: check if resetting to max_health is wise here
 266
 267                 self.SendFlags |= MSF_MOVE;
 268                 self.SendFlags |= MSF_STATUS;
 269         }
 270         else
 271                 SUB_SetFade(self, time + 3, 1);
 272 }
 273
 274 float Monster_CanJump (vector vel)
 275 {
 276         if(self.state)
 277                 return FALSE; // already attacking
 278         if not(self.flags & FL_ONGROUND)
 279                 return FALSE; // not on the ground
 280         if(self.health <= 0)
 281                 return FALSE; // called when dead?
 282         if(time < self.attack_finished_single)
 283                 return FALSE; // still attacking
 284
 285         vector old = self.velocity;
 286
 287         self.velocity = vel;
 288         tracetoss(self, self);
 289         self.velocity = old;
 290         if (trace_ent != self.enemy)
 291                 return FALSE;
 292
 293         return TRUE;
 294 }
 295
 296 float monster_leap (float anm, void() touchfunc, vector vel, float anim_finished)
 297 {
 298         if(!Monster_CanJump(vel))
 299                 return FALSE;
 300
 301         monsters_setframe(anm);
 302         self.state = MONSTER_STATE_ATTACK_LEAP;
 303         self.touch = touchfunc;
 304         self.origin_z += 1;
 305         self.velocity = vel;
 306         self.flags &~= FL_ONGROUND;
 307
 308         self.attack_finished_single = time + anim_finished;
 309
 310         return TRUE;
 311 }
 312
 313 void monster_checkattack(entity e, entity targ)
 314 {
 315         if(e == world)
 316                 return;
 317         if(targ == world)
 318                 return;
 319
 320         if not(e.monster_attackfunc)
 321                 return;
 322
 323         if(time < e.attack_finished_single)
 324                 return;
 325
 326         if(vlen(targ.origin - e.origin) <= e.attack_range)
 327         if(e.monster_attackfunc(MONSTER_ATTACK_MELEE))
 328         {
 329                 monster_sound(e.msound_attack_melee, 0, FALSE);
 330                 return;
 331         }
 332
 333         if(vlen(targ.origin - e.origin) > e.attack_range)
 334         if(e.monster_attackfunc(MONSTER_ATTACK_RANGED))
 335         {
 336                 monster_sound(e.msound_attack_ranged, 0, FALSE);
 337                 return;
 338         }
 339 }
 340
 341 void monster_use ()
 342 {
 343         if (self.enemy)
 344                 return;
 345         if (self.health <= 0)
 346                 return;
 347
 348         if(!monster_isvalidtarget(activator, self))
 349                 return;
 350
 351         self.enemy = activator;
 352 }
 353
 354 float trace_path(vector from, vector to)
 355 {
 356         vector dir = normalize(to - from) * 15, offset = '0 0 0';
 357         float trace1 = trace_fraction;
 358
 359         offset_x = dir_y;
 360         offset_y = -dir_x;
 361         traceline (from+offset, to+offset, TRUE, self);
 362
 363         traceline(from-offset, to-offset, TRUE, self);
 364
 365         return ((trace1 < trace_fraction) ? trace1 : trace_fraction);
 366 }
 367
 368 .float last_trace;
 369 .float last_enemycheck; // for checking enemy
 370 vector monster_pickmovetarget(entity targ)
 371 {
 372         // enemy is always preferred target
 373         if(self.enemy)
 374         {
 375                 self.monster_movestate = MONSTER_MOVE_ENEMY;
 376                 self.last_trace = time + 1.2;
 377                 return self.enemy.origin;
 378         }
 379
 380         switch(self.monster_moveflags)
 381         {
 382                 case MONSTER_MOVE_OWNER:
 383                 {
 384                         self.monster_movestate = MONSTER_MOVE_OWNER;
 385                         self.last_trace = time + 0.3;
 386                         if(self.monster_owner && self.monster_owner.classname != "td_spawnpoint")
 387                                 return self.monster_owner.origin;
 388                 }
 389                 case MONSTER_MOVE_SPAWNLOC:
 390                 {
 391                         self.monster_movestate = MONSTER_MOVE_SPAWNLOC;
 392                         self.last_trace = time + 2;
 393                         return self.pos1;
 394                 }
 395                 case MONSTER_MOVE_NOMOVE:
 396                 {
 397                         self.monster_movestate = MONSTER_MOVE_NOMOVE;
 398                         self.last_trace = time + 2;
 399                         return self.origin;
 400                 }
 401                 default:
 402                 case MONSTER_MOVE_WANDER:
 403                 {
 404                         vector pos;
 405                         self.monster_movestate = MONSTER_MOVE_WANDER;
 406                         self.last_trace = time + 2;
 407
 408                         self.angles_y = random() * 500;
 409                         makevectors(self.angles);
 410                         pos = self.origin + v_forward * 600;
 411
 412                         if(self.flags & FL_FLY || self.flags & FL_SWIM)
 413                         {
 414                                 pos_z = random() * 200;
 415                                 if(random() >= 0.5)
 416                                         pos_z *= -1;
 417                         }
 418
 419                         if(targ)
 420                         {
 421                                 self.last_trace = time + 0.5;
 422                                 pos = targ.origin;
 423                         }
 424
 425                         return pos;
 426                 }
 427         }
 428 }
 429
 430 void monster_move(float runspeed, float walkspeed, float stopspeed, float manim_run, float manim_walk, float manim_idle)
 431 {
 432         fixedmakevectors(self.angles);
 433
 434         if(self.target2)
 435                 self.goalentity = find(world, targetname, self.target2);
 436
 437         entity targ;
 438
 439         if(self.frozen)
 440         {
 441                 self.revive_progress = bound(0, self.revive_progress + frametime * self.revive_speed, 1);
 442                 self.health = max(1, self.max_health * self.revive_progress);
 443
 444                 if(self.sprite) WaypointSprite_UpdateHealth(self.sprite, self.health);
 445
 446                 movelib_beak_simple(stopspeed);
 447
 448                 self.velocity = '0 0 0';
 449                 self.enemy = world;
 450                 self.nextthink = time + 0.1;
 451
 452                 if(self.revive_progress >= 1)
 453                         Unfreeze(self); // wait for next think before attacking
 454
 455                 // don't bother updating angles here?
 456                 if(self.origin != self.oldorigin)
 457                 {
 458                         self.oldorigin = self.origin;
 459                         self.SendFlags |= MSF_MOVE;
 460                 }
 461
 462                 return; // no moving while frozen
 463         }
 464
 465         if(self.flags & FL_SWIM)
 466         {
 467                 if(self.waterlevel < WATERLEVEL_WETFEET)
 468                 {
 469                         if(time >= self.last_trace)
 470                         {
 471                                 self.last_trace = time + 0.4;
 472
 473                                 Damage (self, world, world, 2, DEATH_DROWN, self.origin, '0 0 0');
 474                                 self.angles = '90 90 0';
 475                                 if(random() < 0.5)
 476                                 {
 477                                         self.velocity_y += random() * 50;
 478                                         self.velocity_x -= random() * 50;
 479                                 }
 480                                 else
 481                                 {
 482                                         self.velocity_y -= random() * 50;
 483                                         self.velocity_x += random() * 50;
 484                                 }
 485                                 self.velocity_z += random() * 150;
 486                         }
 487
 488
 489                         self.movetype = MOVETYPE_BOUNCE;
 490                         //self.velocity_z = -200;
 491
 492                         self.SendFlags |= MSF_MOVE | MSF_ANG;
 493
 494                         return;
 495                 }
 496                 else
 497                 {
 498                         self.angles = '0 0 0';
 499                         self.movetype = MOVETYPE_WALK;
 500                 }
 501         }
 502
 503         targ = self.goalentity;
 504
 505         monster_target = targ;
 506         monster_speed_run = runspeed;
 507         monster_speed_walk = walkspeed;
 508
 509         if(MUTATOR_CALLHOOK(MonsterMove) || gameover || (round_handler_IsActive() && !round_handler_IsRoundStarted()) || time < game_starttime || (autocvar_g_campaign && !campaign_bots_may_start) || time < self.spawn_time)
 510         {
 511                 runspeed = walkspeed = 0;
 512                 if(time >= self.spawn_time)
 513                         monsters_setframe(manim_idle);
 514                 movelib_beak_simple(stopspeed);
 515                 self.SendFlags |= MSF_MOVE;
 516                 return;
 517         }
 518
 519         targ = monster_target;
 520         runspeed = monster_speed_run;
 521         walkspeed = monster_speed_walk;
 522
 523         if(teamplay)
 524         if(autocvar_g_monsters_teams)
 525         if(IsDifferentTeam(self.monster_owner, self))
 526                 self.monster_owner = world;
 527
 528         if(time >= self.last_enemycheck)
 529         {
 530                 if not(monster_isvalidtarget(self.enemy, self))
 531                         self.enemy = world;
 532                 self.last_enemycheck = time + 2;
 533         }
 534
 535         if(self.enemy && self.enemy.health < 1)
 536                 self.enemy = world; // enough!
 537
 538         if not(self.enemy)
 539         {
 540                 self.enemy = FindTarget(self);
 541                 if(self.enemy)
 542                         monster_sound(self.msound_sight, 0, FALSE);
 543         }
 544
 545         if(self.state == MONSTER_STATE_ATTACK_MELEE && time >= self.attack_finished_single)
 546                 self.state = 0;
 547
 548         if(self.state != MONSTER_STATE_ATTACK_MELEE) // don't move if set
 549         if(time >= self.last_trace || self.enemy) // update enemy instantly
 550                 self.moveto = monster_pickmovetarget(targ);
 551
 552         if not(self.enemy)
 553                 monster_sound(self.msound_idle, 5, TRUE);
 554
 555         if(self.state != MONSTER_STATE_ATTACK_LEAP && self.state != MONSTER_STATE_ATTACK_MELEE)
 556                 self.steerto = steerlib_attract2(self.moveto, 0.5, 500, 0.95);
 557
 558         if(self.state == MONSTER_STATE_ATTACK_LEAP && (self.flags & FL_ONGROUND))
 559         {
 560                 self.state = 0;
 561                 self.touch = MonsterTouch;
 562         }
 563
 564         //self.steerto = steerlib_attract2(self.moveto, 0.5, 500, 0.95);
 565
 566         float turny = 0;
 567         vector real_angle = vectoangles(self.steerto) - self.angles;
 568
 569         if(self.state != MONSTER_STATE_ATTACK_LEAP && self.state != MONSTER_STATE_ATTACK_MELEE)
 570                 turny = 20;
 571
 572         if(self.flags & FL_SWIM)
 573                 turny = vlen(self.angles - self.moveto);
 574
 575         if(turny)
 576         {
 577                 turny = bound(turny * -1, shortangle_f(real_angle_y, self.angles_y), turny);
 578                 self.angles_y += turny;
 579         }
 580
 581         if(self.state == MONSTER_STATE_ATTACK_MELEE)
 582                 self.moveto = self.origin;
 583         else if(self.enemy)
 584                 self.moveto = self.moveto * 0.9 + ((self.origin + v_forward * 500) + randomvec() * 400) * 0.1;
 585
 586         if not(self.flags & FL_FLY || self.flags & FL_SWIM)
 587                 self.moveto_z = self.origin_z;
 588
 589         float l = vlen(self.moveto - self.origin);
 590         float t1 = trace_path(self.origin+'0 0 10', self.moveto+'0 0 10');
 591         float t2 = trace_path(self.origin-'0 0 15', self.moveto-'0 0 15');
 592
 593         if(self.flags & FL_FLY || self.flags & FL_SWIM)
 594                 v_forward = normalize(self.moveto - self.origin);
 595
 596         if(t1*l-t2*l>50 && (t1*l > 100 || t1 > 0.8))
 597         if(self.flags & FL_ONGROUND)
 598                 movelib_jump_simple(100);
 599
 600         if(vlen(self.origin - self.moveto) > 64)
 601         {
 602                 if(self.flags & FL_FLY || self.flags & FL_SWIM)
 603                         movelib_move_simple(v_forward, ((self.enemy) ? runspeed : walkspeed), 0.6);
 604                 else
 605                         movelib_move_simple_gravity(v_forward, ((self.enemy) ? runspeed : walkspeed), 0.6);
 606                 if(time > self.pain_finished)
 607                 if(time > self.attack_finished_single)
 608                 if(vlen(self.velocity) > 0)
 609                         monsters_setframe((self.enemy) ? manim_run : manim_walk);
 610                 else
 611                         monsters_setframe(manim_idle);
 612         }
 613         else
 614         {
 615                 entity e = find(world, targetname, self.target2);
 616                 if(e.target2)
 617                         self.target2 = e.target2;
 618                 else if(e.target)
 619                         self.target2 = e.target;
 620
 621                 movelib_beak_simple(stopspeed);
 622                 if(time > self.attack_finished_single)
 623                 if(time > self.pain_finished)
 624                 if (vlen(self.velocity) <= 30)
 625                         monsters_setframe(manim_idle);
 626         }
 627
 628         monster_checkattack(self, self.enemy);
 629
 630         if(self.angles != self.oldangles)
 631         {
 632                 self.oldangles = self.angles;
 633                 self.SendFlags |= MSF_ANG;
 634         }
 635
 636         if(self.origin != self.oldorigin)
 637         {
 638                 self.oldorigin = self.origin;
 639                 self.SendFlags |= MSF_MOVE;
 640         }
 641 }
 642
 643 void monster_dead_think()
 644 {
 645         self.think = monster_dead_think;
 646         self.nextthink = time + 0.3; // don't need to update so often now
 647
 648         self.deadflag = DEAD_DEAD;
 649
 650         if(time >= self.ltime)
 651         {
 652                 Monster_Fade();
 653                 return;
 654         }
 655
 656         self.SendFlags |= MSF_MOVE; // keep up to date on the monster's location
 657 }
 658
 659 void monsters_setstatus()
 660 {
 661         self.stat_monsters_total = monsters_total;
 662         self.stat_monsters_killed = monsters_killed;
 663 }
 664
 665 void Monster_Appear()
 666 {
 667         self.enemy = activator;
 668         self.spawnflags &~= MONSTERFLAG_APPEAR;
 669         self.monster_spawnfunc();
 670 }
 671
 672 float Monster_CheckAppearFlags(entity ent)
 673 {
 674         if not(ent.spawnflags & MONSTERFLAG_APPEAR)
 675                 return FALSE;
 676
 677         ent.think = func_null;
 678         ent.nextthink = 0;
 679         ent.use = Monster_Appear;
 680         ent.flags = FL_MONSTER; // set so this monster can get butchered
 681
 682         return TRUE;
 683 }
 684
 685 void monsters_reset()
 686 {
 687         setorigin(self, self.pos1);
 688         self.angles = self.pos2;
 689
 690         self.health = self.max_health;
 691         self.velocity = '0 0 0';
 692         self.enemy = world;
 693         self.goalentity = world;
 694         self.attack_finished_single = 0;
 695         self.moveto = self.origin;
 696
 697         WaypointSprite_UpdateHealth(self.sprite, self.health);
 698 }
 699
 700 float monster_send(entity to, float sf)
 701 {
 702         WriteByte(MSG_ENTITY, ENT_CLIENT_MONSTER);
 703         WriteByte(MSG_ENTITY, sf);
 704         if(sf & MSF_SETUP)
 705         {
 706             WriteByte(MSG_ENTITY, self.monsterid);
 707
 708             WriteCoord(MSG_ENTITY, self.origin_x);
 709             WriteCoord(MSG_ENTITY, self.origin_y);
 710             WriteCoord(MSG_ENTITY, self.origin_z);
 711
 712             WriteAngle(MSG_ENTITY, self.angles_x);
 713             WriteAngle(MSG_ENTITY, self.angles_y);
 714
 715                 WriteByte(MSG_ENTITY, self.skin);
 716                 WriteByte(MSG_ENTITY, self.team);
 717     }
 718
 719     if(sf & MSF_ANG)
 720     {
 721         WriteShort(MSG_ENTITY, rint(self.angles_x));
 722         WriteShort(MSG_ENTITY, rint(self.angles_y));
 723     }
 724
 725     if(sf & MSF_MOVE)
 726     {
 727         WriteShort(MSG_ENTITY, rint(self.origin_x));
 728         WriteShort(MSG_ENTITY, rint(self.origin_y));
 729         WriteShort(MSG_ENTITY, rint(self.origin_z));
 730
 731         WriteShort(MSG_ENTITY, rint(self.velocity_x));
 732         WriteShort(MSG_ENTITY, rint(self.velocity_y));
 733         WriteShort(MSG_ENTITY, rint(self.velocity_z));
 734
 735         WriteShort(MSG_ENTITY, rint(self.angles_y));
 736     }
 737
 738     if(sf & MSF_ANIM)
 739     {
 740         WriteCoord(MSG_ENTITY, self.anim_start_time);
 741         WriteByte(MSG_ENTITY, self.frame);
 742     }
 743
 744     if(sf & MSF_STATUS)
 745     {
 746                 WriteByte(MSG_ENTITY, self.skin);
 747
 748         WriteByte(MSG_ENTITY, self.team);
 749
 750                 WriteByte(MSG_ENTITY, self.deadflag);
 751
 752         if(self.health <= 0)
 753             WriteByte(MSG_ENTITY, 0);
 754         else
 755             WriteByte(MSG_ENTITY, ceil((self.health / self.max_health) * 255));
 756     }
 757
 758         return TRUE;
 759 }
 760
 761 void monster_link(void() spawnproc)
 762 {
 763     Net_LinkEntity(self, TRUE, 0, monster_send);
 764     self.think      = spawnproc;
 765     self.nextthink  = time;
 766 }
 767
 768 void monsters_corpse_damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 769 {
 770         self.health -= damage;
 771
 772         Violence_GibSplash_At(hitloc, force, 2, bound(0, damage, 200) / 16, self, attacker);
 773
 774         if(self.health <= -100) // 100 health until gone?
 775         {
 776                 Violence_GibSplash_At(hitloc, force, 2, bound(0, damage, 200) / 16, self, attacker);
 777
 778                 self.think = SUB_Remove;
 779                 self.nextthink = time + 0.1;
 780         }
 781 }
 782
 783 void monster_die()
 784 {
 785         self.think = monster_dead_think;
 786         self.nextthink = self.ticrate;
 787         self.ltime = time + 5;
 788
 789         monster_dropitem();
 790
 791         WaypointSprite_Kill(self.sprite);
 792
 793         if(self.weaponentity)
 794         {
 795                 remove(self.weaponentity);
 796                 self.weaponentity = world;
 797         }
 798
 799         monster_sound(self.msound_death, 0, FALSE);
 800
 801         if(!(self.spawnflags & MONSTERFLAG_SPAWNED) && !self.monster_respawned)
 802                 monsters_killed += 1;
 803
 804         if(self.candrop && self.weapon)
 805                 W_ThrowNewWeapon(self, self.weapon, 0, self.origin, randomvec() * 150 + '0 0 325');
 806
 807         if(IS_CLIENT(self.realowner))
 808                 self.realowner.monstercount -= 1;
 809
 810         self.event_damage       = monsters_corpse_damage;
 811         self.solid                      = SOLID_CORPSE;
 812         self.takedamage         = DAMAGE_AIM;
 813         self.enemy                      = world;
 814         self.movetype           = MOVETYPE_TOSS;
 815         self.moveto                     = self.origin;
 816         self.touch                      = MonsterTouch; // reset incase monster was pouncing
 817
 818         if not(self.flags & FL_FLY)
 819                 self.velocity = '0 0 0';
 820
 821         self.SendFlags |= MSF_MOVE;
 822
 823         // number of monsters spawned with mobspawn command
 824         totalspawned -= 1;
 825
 826         MON_ACTION(self.monsterid, MR_DEATH);
 827 }
 828
 829 void monsters_damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 830 {
 831         if(self.frozen && deathtype != DEATH_KILL)
 832                 return;
 833
 834         if(time < self.pain_finished && deathtype != DEATH_KILL)
 835                 return;
 836
 837         if(time < self.spawnshieldtime)
 838                 return;
 839
 840         if(deathtype != DEATH_KILL)
 841                 damage *= self.armorvalue;
 842
 843         if(self.weaponentity && self.weaponentity.classname == "shield")
 844                 self.weaponentity.health -= damage;
 845
 846         self.health -= damage;
 847
 848         if(self.sprite)
 849                 WaypointSprite_UpdateHealth(self.sprite, self.health);
 850
 851         self.dmg_time = time;
 852
 853         if(sound_allowed(MSG_BROADCAST, attacker) && deathtype != DEATH_DROWN)
 854                 spamsound (self, CH_PAIN, "misc/bodyimpact1.wav", VOL_BASE, ATTN_NORM);  // FIXME: PLACEHOLDER
 855
 856         self.velocity += force * self.damageforcescale;
 857
 858         if(deathtype != DEATH_DROWN)
 859         {
 860                 Violence_GibSplash_At(hitloc, force, 2, bound(0, damage, 200) / 16, self, attacker);
 861                 if (damage > 50)
 862                         Violence_GibSplash_At(hitloc, force * -0.1, 3, 1, self, attacker);
 863                 if (damage > 100)
 864                         Violence_GibSplash_At(hitloc, force * -0.2, 3, 1, self, attacker);
 865         }
 866
 867         if(self.health <= 0)
 868         {
 869                 if(self.sprite)
 870                 {
 871                         // Update one more time to avoid waypoint fading without emptying healthbar
 872                         WaypointSprite_UpdateHealth(self.sprite, 0);
 873                 }
 874
 875                 if(deathtype == DEATH_KILL)
 876                         self.candrop = FALSE; // killed by mobkill command
 877
 878                 // TODO: fix this?
 879                 activator = attacker;
 880                 other = self.enemy;
 881                 SUB_UseTargets();
 882                 self.target2 = self.oldtarget2; // reset to original target on death, incase we respawn
 883
 884                 monster_die();
 885
 886                 frag_attacker = attacker;
 887                 frag_target = self;
 888                 MUTATOR_CALLHOOK(MonsterDies);
 889
 890                 if(self.health <= -100) // check if we're already gibbed
 891                 {
 892                         Violence_GibSplash(self, 1, 0.5, attacker);
 893
 894                         self.think = SUB_Remove;
 895                         self.nextthink = time + 0.1;
 896                 }
 897         }
 898
 899         self.SendFlags |= MSF_STATUS;
 900 }
 901
 902 void monster_think()
 903 {
 904         self.think = monster_think;
 905         self.nextthink = self.ticrate;
 906
 907         MON_ACTION(self.monsterid, MR_THINK);
 908 }
 909
 910 void monster_spawn()
 911 {
 912         MON_ACTION(self.monsterid, MR_SETUP);
 913
 914         if not(self.monster_respawned)
 915                 Monster_CheckMinibossFlag();
 916
 917         self.max_health = self.health;
 918         self.pain_finished = self.nextthink;
 919         self.anim_start_time = time;
 920
 921         if not(self.noalign)
 922         {
 923                 setorigin(self, self.origin + '0 0 20');
 924                 tracebox(self.origin + '0 0 100', self.mins, self.maxs, self.origin - '0 0 10000', MOVE_WORLDONLY, self);
 925                 setorigin(self, trace_endpos);
 926         }
 927
 928         if not(self.monster_respawned)
 929         if not(self.skin)
 930                 self.skin = rint(random() * 4);
 931
 932         if not(self.attack_range)
 933                 self.attack_range = autocvar_g_monsters_attack_range;
 934
 935         self.pos1 = self.origin;
 936
 937         monster_setupsounds(self.netname);
 938
 939         monster_precachesounds(self);
 940
 941         if(teamplay)
 942                 self.monster_attack = TRUE; // we can have monster enemies in team games
 943
 944         if(autocvar_g_monsters_healthbars)
 945         {
 946                 WaypointSprite_Spawn(strzone(strdecolorize(self.monster_name)), 0, 600, self, '0 0 1' * (self.maxs_z + 15), world, 0, self, sprite, FALSE, RADARICON_DANGER, ((self.team) ? Team_ColorRGB(self.team) : '1 0 0'));
 947                 WaypointSprite_UpdateMaxHealth(self.sprite, self.max_health);
 948                 WaypointSprite_UpdateHealth(self.sprite, self.health);
 949         }
 950
 951         monster_sound(self.msound_spawn, 0, FALSE);
 952
 953         MUTATOR_CALLHOOK(MonsterSpawn);
 954
 955         self.think = monster_think;
 956         self.nextthink = time + self.ticrate;
 957
 958         self.SendFlags |= MSF_SETUP;
 959 }
 960
 961 float monster_initialize(float mon_id, float nodrop)
 962 {
 963         if not(autocvar_g_monsters)
 964                 return FALSE;
 965
 966         vector min_s, max_s;
 967         entity mon = get_monsterinfo(mon_id);
 968
 969         // support for quake style removing monsters based on skill
 970         switch(monster_skill)
 971         {
 972                 case 1: if(self.spawnflags & MONSTERSKILL_NOTEASY)              return FALSE; break;
 973                 case 2: if(self.spawnflags & MONSTERSKILL_NOTMEDIUM)    return FALSE; break;
 974                 case 3: if(self.spawnflags & MONSTERSKILL_NOTHARD)              return FALSE; break;
 975                 case 4: if(self.spawnflags & MONSTERSKILL_NOTINSANE)    return FALSE; break;
 976                 case 5: if(self.spawnflags & MONSTERSKILL_NOTNIGHTMARE) return FALSE; break;
 977         }
 978
 979         if(self.monster_name == "")
 980                 self.monster_name = M_NAME(mon_id);
 981
 982         if(self.team && !teamplay)
 983                 self.team = 0;
 984
 985         self.flags = FL_MONSTER;
 986
 987         if not(self.spawnflags & MONSTERFLAG_SPAWNED) // naturally spawned monster
 988         if not(self.monster_respawned)
 989                 monsters_total += 1;
 990
 991         min_s = mon.mins;
 992         max_s = mon.maxs;
 993
 994         self.netname = mon.netname;
 995
 996         setsize(self, min_s, max_s);
 997         self.takedamage                 = DAMAGE_AIM;
 998         self.bot_attack                 = TRUE;
 999         self.iscreature                 = TRUE;
1000         self.teleportable               = TRUE;
1001         self.damagedbycontents  = TRUE;
1002         self.monsterid                  = mon_id;
1003         self.damageforcescale   = 0;
1004         self.event_damage               = monsters_damage;
1005         self.touch                              = MonsterTouch;
1006         self.use                                = monster_use;
1007         self.solid                              = SOLID_BBOX;
1008         self.movetype                   = MOVETYPE_WALK;
1009         self.spawnshieldtime    = time + autocvar_g_monsters_spawnshieldtime;
1010         monsters_spawned           += 1;
1011         self.enemy                              = world;
1012         self.velocity                   = '0 0 0';
1013         self.moveto                             = self.origin;
1014         self.pos2                               = self.angles;
1015         self.reset                              = monsters_reset;
1016         self.candrop                    = TRUE;
1017         self.view_ofs                   = '0 0 1' * (self.maxs_z * 0.5);
1018         self.oldtarget2                 = self.target2;
1019         self.deadflag                   = DEAD_NO;
1020         self.noalign                    = nodrop;
1021         self.spawn_time                 = time;
1022         self.gravity                    = 1;
1023         self.dphitcontentsmask  = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_BOTCLIP | DPCONTENTS_MONSTERCLIP;
1024
1025         if(mon.spawnflags & MONSTER_TYPE_SWIM)
1026                 self.flags |= FL_SWIM;
1027
1028         if(mon.spawnflags & MONSTER_TYPE_FLY)
1029         {
1030                 self.flags |= FL_FLY;
1031                 self.movetype = MOVETYPE_FLY;
1032         }
1033
1034         if not(self.scale)
1035                 self.scale = 1;
1036
1037         if(mon.spawnflags & MONSTER_SIZE_BROKEN)
1038                 self.scale = 1.3;
1039
1040         if not(self.ticrate)
1041                 self.ticrate = autocvar_g_monsters_think_delay;
1042
1043         self.ticrate = bound(sys_frametime, self.ticrate, 60);
1044
1045         if not(self.armorvalue)
1046                 self.armorvalue = 1; // multiplier
1047
1048         if not(self.target_range)
1049                 self.target_range = autocvar_g_monsters_target_range;
1050
1051         if not(self.respawntime)
1052                 self.respawntime = autocvar_g_monsters_respawn_delay;
1053
1054         if not(self.monster_moveflags)
1055                 self.monster_moveflags = MONSTER_MOVE_WANDER;
1056
1057         monster_link(monster_spawn);
1058
1059         return TRUE;
1060 }