qcsrc/server/monsters/monster/shalrath.qc

   1 // size
   2 const vector SHALRATH_MIN = '-36 -36 -24';
   3 const vector SHALRATH_MAX = '36 36 50';
   4
   5 // model
   6 string SHALRATH_MODEL = "models/monsters/mage.dpm";
   7
   8 #ifdef SVQC
   9 // cvars
  10 float autocvar_g_monster_shalrath;
  11 float autocvar_g_monster_shalrath_health;
  12 float autocvar_g_monster_shalrath_speed;
  13 float autocvar_g_monster_shalrath_attack_spike_damage;
  14 float autocvar_g_monster_shalrath_attack_spike_radius;
  15 float autocvar_g_monster_shalrath_attack_spike_delay;
  16 float autocvar_g_monster_shalrath_attack_melee_damage;
  17 float autocvar_g_monster_shalrath_attack_melee_delay;
  18 float autocvar_g_monster_shalrath_heal_self;
  19 float autocvar_g_monster_shalrath_heal_friends;
  20 float autocvar_g_monster_shalrath_heal_minhealth;
  21 float autocvar_g_monster_shalrath_heal_range;
  22 float autocvar_g_monster_shalrath_heal_delay;
  23 float autocvar_g_monster_shalrath_shield_time;
  24 float autocvar_g_monster_shalrath_shield_delay;
  25 float autocvar_g_monster_shalrath_shield_blockpercent;
  26 float autocvar_g_monster_shalrath_attack_grenade_damage;
  27 float autocvar_g_monster_shalrath_attack_grenade_edgedamage;
  28 float autocvar_g_monster_shalrath_attack_grenade_radius;
  29 float autocvar_g_monster_shalrath_attack_grenade_lifetime;
  30 float autocvar_g_monster_shalrath_attack_grenade_force;
  31 float autocvar_g_monster_shalrath_attack_grenade_chance;
  32
  33 // animations
  34 const float shalrath_anim_idle          = 0;
  35 const float shalrath_anim_walk          = 1;
  36 const float shalrath_anim_attack        = 2;
  37 const float shalrath_anim_pain          = 3;
  38 const float shalrath_anim_death         = 4;
  39 const float shalrath_anim_run           = 5;
  40
  41 void() ShalMissile;
  42 void() shalrath_heal;
  43 void() shalrath_shield;
  44 void() shalrath_shield_die;
  45
  46 void shalrath_think()
  47 {
  48         entity head;
  49         float friend_needshelp = FALSE, need_hpammo = FALSE;
  50
  51         FOR_EACH_PLAYER(head)
  52         {
  53                 need_hpammo = ((g_minstagib) ? head.ammo_cells < start_ammo_cells : head.health < autocvar_g_balance_health_regenstable);
  54                 if not(IsDifferentTeam(head, self))
  55                 if(head.health > 0)
  56                 if(vlen(head.origin - self.origin) < autocvar_g_monster_shalrath_heal_range)
  57                 if(need_hpammo)
  58                 {
  59                         friend_needshelp = TRUE;
  60                         break; // found 1 player near us who is low on health
  61                 }
  62         }
  63         FOR_EACH_MONSTER(head) if(head != self)
  64         {
  65                 if not(IsDifferentTeam(head, self))
  66                 if(head.health > 0)
  67                 if(vlen(head.origin - self.origin) < autocvar_g_monster_shalrath_heal_range)
  68                 if(head.health < head.max_health)
  69                 {
  70                         friend_needshelp = TRUE;
  71                         break; // found 1 player near us who is low on health
  72                 }
  73         }
  74
  75         self.think = shalrath_think;
  76         self.nextthink = time + self.ticrate;
  77
  78         if(self.weaponentity)
  79         if(time >= self.weaponentity.ltime)
  80                 shalrath_shield_die();
  81
  82         if(self.health < autocvar_g_monster_shalrath_heal_minhealth || friend_needshelp)
  83         if(time >= self.attack_finished_single)
  84         if(random() < 0.5)
  85                 shalrath_heal();
  86
  87         if(self.enemy)
  88         if(self.health < self.max_health)
  89         if(time >= self.lastshielded)
  90         if(random() < 0.5)
  91                 shalrath_shield();
  92
  93         monster_move(autocvar_g_monster_shalrath_speed, autocvar_g_monster_shalrath_speed, 50, shalrath_anim_walk, shalrath_anim_run, shalrath_anim_idle);
  94 }
  95
  96 void shalrathattack_melee()
  97 {
  98         monster_melee(self.enemy, autocvar_g_monster_shalrath_attack_melee_damage, 0.3, DEATH_MONSTER_MAGE, TRUE);
  99
 100         self.delay = -1;
 101         self.monster_delayedattack = func_null;
 102 }
 103
 104 void shalrath_grenade_explode()
 105 {
 106         pointparticles(particleeffectnum("explosion_small"), self.origin, '0 0 0', 1);
 107
 108         sound(self, CH_SHOTS, "weapons/grenade_impact.wav", VOL_BASE, ATTN_NORM);
 109         RadiusDamage (self, self.realowner, autocvar_g_monster_shalrath_attack_grenade_damage, autocvar_g_monster_shalrath_attack_grenade_edgedamage, autocvar_g_monster_shalrath_attack_grenade_radius, world, autocvar_g_monster_shalrath_attack_grenade_force, DEATH_MONSTER_MAGE, other);
 110         remove(self);
 111 }
 112
 113 void shalrath_grenade_touch()
 114 {
 115         if(IS_PLAYER(other))
 116         {
 117                 PROJECTILE_TOUCH;
 118                 shalrath_grenade_explode();
 119                 return;
 120         }
 121 }
 122
 123 void shalrath_throw_itemgrenade()
 124 {
 125         makevectors(self.angles);
 126
 127         W_SetupShot_ProjectileSize (self, '-64 -64 -64', '64 64 64', FALSE, 4, "", CH_WEAPON_A, autocvar_g_monster_shalrath_attack_grenade_damage);
 128         w_shotdir = v_forward; // no TrueAim for grenades please
 129
 130         entity gren = spawn ();
 131         gren.owner = gren.realowner = self;
 132         gren.classname = "grenade";
 133         gren.bot_dodge = FALSE;
 134         gren.movetype = MOVETYPE_BOUNCE;
 135         gren.solid = SOLID_TRIGGER;
 136         gren.projectiledeathtype = DEATH_MONSTER_MAGE;
 137         setorigin(gren, w_shotorg);
 138         setsize(gren, '-64 -64 -64', '64 64 64');
 139
 140         gren.nextthink = time + autocvar_g_monster_shalrath_attack_grenade_lifetime;
 141         gren.think = shalrath_grenade_explode;
 142         gren.use = shalrath_grenade_explode;
 143         gren.touch = shalrath_grenade_touch;
 144
 145         gren.missile_flags = MIF_SPLASH | MIF_ARC;
 146         W_SETUPPROJECTILEVELOCITY_UP(gren, g_monster_shalrath_attack_grenade);
 147
 148         gren.flags = FL_PROJECTILE;
 149
 150         setmodel(gren, "models/items/g_h50.md3");
 151
 152         self.attack_finished_single = time + 1.5;
 153 }
 154
 155 void ShalHome()
 156 {
 157         local vector dir = '0 0 0', vtemp = self.enemy.origin + '0 0 10';
 158
 159         if (self.enemy.health <= 0 || self.owner.health <= 0 || time >= self.ltime)
 160         {
 161                 remove(self);
 162                 return;
 163         }
 164         dir = normalize(vtemp - self.origin);
 165         UpdateCSQCProjectile(self);
 166         if (monster_skill == 3)
 167                 self.velocity = dir * 350;
 168         else
 169                 self.velocity = dir * 250;
 170         self.nextthink = time + 0.2;
 171         self.think = ShalHome;
 172 }
 173
 174 void shal_spike_explode()
 175 {
 176         self.event_damage = func_null;
 177
 178         pointparticles(particleeffectnum("explosion_small"), self.origin, '0 0 0', 1);
 179         RadiusDamage (self, self.realowner, autocvar_g_monster_shalrath_attack_spike_damage, autocvar_g_monster_shalrath_attack_spike_damage * 0.5, autocvar_g_monster_shalrath_attack_spike_radius, world, 0, DEATH_MONSTER_MAGE, other);
 180
 181         remove (self);
 182 }
 183
 184 void shal_spike_touchexplode()
 185 {
 186         PROJECTILE_TOUCH;
 187
 188         shal_spike_explode();
 189 }
 190
 191 void ShalMissile()
 192 {
 193         local   entity  missile = world;
 194         local   vector  dir = '0 0 0';
 195         local   float   dist = 0;
 196
 197         self.effects |= EF_MUZZLEFLASH;
 198
 199         missile = spawn ();
 200         missile.owner = missile.realowner = self;
 201
 202         monster_makevectors(self.enemy);
 203
 204         dir = normalize((self.enemy.origin + '0 0 10') - self.origin);
 205         dist = vlen (self.enemy.origin - self.origin);
 206
 207         missile.think = ShalHome;
 208         missile.ltime = time + 7;
 209         missile.nextthink = time;
 210         missile.solid = SOLID_BBOX;
 211         missile.movetype = MOVETYPE_FLYMISSILE;
 212         missile.flags = FL_PROJECTILE;
 213         setorigin (missile, self.origin + v_forward * 14 + '0 0 30' + v_right * -14);
 214         setsize (missile, '0 0 0', '0 0 0');
 215         missile.velocity = dir * 400;
 216         missile.avelocity = '300 300 300';
 217         missile.enemy = self.enemy;
 218         missile.touch = shal_spike_touchexplode;
 219
 220         CSQCProjectile(missile, TRUE, PROJECTILE_VORE_SPIKE, TRUE);
 221 }
 222
 223 void shalrath_heal()
 224 {
 225         entity head;
 226         if(self.health < self.max_health) // only show our effect if we are healing ourself too
 227                 pointparticles(particleeffectnum("healing_fx"), self.origin, '0 0 0', 1);
 228         self.health = bound(0, self.health + autocvar_g_monster_shalrath_heal_self, self.max_health);
 229         WaypointSprite_UpdateHealth(self.sprite, self.health);
 230         monsters_setframe(shalrath_anim_attack);
 231         self.attack_finished_single = time + autocvar_g_monster_shalrath_heal_delay;
 232
 233         for(head = world; (head = findfloat(head, monster_attack, TRUE)); )
 234         {
 235                 if(head.health > 0)
 236                 if not(head.frozen)
 237                 if(vlen(head.origin - self.origin) < autocvar_g_monster_shalrath_heal_range)
 238                 if not(IsDifferentTeam(head, self))
 239                 {
 240                         if(IS_PLAYER(head))
 241                         {
 242                                 if((g_minstagib && head.ammo_cells < start_ammo_cells) || head.health < start_health)
 243                                         pointparticles(particleeffectnum(((g_minstagib) ? "ammoregen_fx" : "healing_fx")), head.origin, '0 0 0', 1);
 244                                 if(g_minstagib)
 245                                         head.ammo_cells = bound(0, head.ammo_cells + 1, start_ammo_cells);
 246                                 else
 247                                         head.health = bound(0, head.health + autocvar_g_monster_shalrath_heal_friends, g_pickup_healthmedium_max);
 248                         }
 249                         else
 250                         {
 251                                 if(head.health < head.max_health)
 252                                         pointparticles(particleeffectnum("healing_fx"), head.origin, '0 0 0', 1);
 253                                 head.health = bound(0, head.health + autocvar_g_monster_shalrath_heal_friends, head.max_health);
 254                                 WaypointSprite_UpdateHealth(head.sprite, head.health);
 255                         }
 256                 }
 257         }
 258 }
 259
 260 void shalrath_shield_die()
 261 {
 262         if not(self.weaponentity)
 263                 return; // why would this be called without a shield?
 264
 265         self.armorvalue = 1;
 266
 267         remove(self.weaponentity);
 268
 269         self.weaponentity = world;
 270 }
 271
 272 void shalrath_shield()
 273 {
 274         if(self.weaponentity)
 275                 return; // already have a shield
 276
 277         entity shield = spawn();
 278
 279         shield.owner = self;
 280         shield.team = self.team;
 281         shield.ltime = time + autocvar_g_monster_shalrath_shield_time;
 282         shield.health = 70;
 283         shield.classname = "shield";
 284         shield.effects = EF_ADDITIVE;
 285         shield.movetype = MOVETYPE_NOCLIP;
 286         shield.solid = SOLID_TRIGGER;
 287         shield.avelocity = '7 0 11';
 288         shield.scale = self.scale * 0.6;
 289
 290         setattachment(shield, self, "");
 291         setmodel(shield, "models/ctf/shield.md3");
 292         setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
 293
 294         self.weaponentity = shield;
 295
 296         self.lastshielded = time + autocvar_g_monster_shalrath_shield_delay;
 297
 298         monsters_setframe(shalrath_anim_attack);
 299         self.attack_finished_single = time + 1;
 300
 301         self.armorvalue = autocvar_g_monster_shalrath_shield_blockpercent / 100;
 302 }
 303
 304 float mage_attack(float attack_type)
 305 {
 306         switch(attack_type)
 307         {
 308                 case MONSTER_ATTACK_MELEE:
 309                 {
 310                         self.monster_delayedattack = shalrathattack_melee;
 311                         self.delay = time + 0.2;
 312                         monsters_setframe(shalrath_anim_attack);
 313                         self.attack_finished_single = time + autocvar_g_monster_shalrath_attack_melee_delay;
 314
 315                         return TRUE;
 316                 }
 317                 case MONSTER_ATTACK_RANGED:
 318                 {
 319                         if(random() < autocvar_g_monster_shalrath_attack_grenade_chance / 100)
 320                         {
 321                                 shalrath_throw_itemgrenade();
 322                                 return TRUE;
 323                         }
 324
 325                         monsters_setframe(shalrath_anim_attack);
 326                         self.delay = time + 0.2;
 327                         self.attack_finished_single = time + autocvar_g_monster_shalrath_attack_spike_delay;
 328                         self.monster_delayedattack = ShalMissile;
 329
 330                         return TRUE;
 331                 }
 332         }
 333
 334         return FALSE;
 335 }
 336
 337 void shalrath_die()
 338 {
 339         Monster_CheckDropCvars ("shalrath");
 340
 341         self.think = monster_dead_think;
 342         self.nextthink = time + self.ticrate;
 343         self.ltime = time + 5;
 344         monsters_setframe(shalrath_anim_death);
 345
 346         monster_hook_death(); // for post-death mods
 347 }
 348
 349 void shalrath_spawn()
 350 {
 351         if not(self.health)
 352                 self.health = autocvar_g_monster_shalrath_health;
 353
 354         self.damageforcescale   = 0.003;
 355         self.classname                  = "monster_shalrath";
 356         self.monster_attackfunc = mage_attack;
 357         self.nextthink                  = time + random() * 0.5 + 0.1;
 358         self.think                              = shalrath_think;
 359
 360         monsters_setframe(shalrath_anim_walk);
 361
 362         monster_setupsounds("shalrath");
 363
 364         monster_hook_spawn(); // for post-spawn mods
 365 }
 366
 367 void spawnfunc_monster_mage()
 368 {
 369         if not(autocvar_g_monster_shalrath) { remove(self); return; }
 370
 371         self.monster_spawnfunc = spawnfunc_monster_mage;
 372
 373         if(Monster_CheckAppearFlags(self))
 374                 return;
 375
 376         if not (monster_initialize(
 377                          "Mage", MONSTER_MAGE,
 378                          SHALRATH_MIN, SHALRATH_MAX,
 379                          FALSE,
 380                          shalrath_die, shalrath_spawn))
 381         {
 382                 remove(self);
 383                 return;
 384         }
 385 }
 386
 387 // compatibility with old spawns
 388 void spawnfunc_monster_shalrath() { spawnfunc_monster_mage(); }
 389
 390 #endif // SVQC