qcsrc/common/monsters/lib/monsters.qc

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