qcsrc/server/monsters/monster/mage.qc

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