qcsrc/common/monsters/monster/mage.qc

   1 #ifdef REGISTER_MONSTER
   2 REGISTER_MONSTER(
   3 /* MON_##id   */ MAGE,
   4 /* function   */ m_mage,
   5 /* spawnflags */ MON_FLAG_MELEE | MON_FLAG_RANGED,
   6 /* mins,maxs  */ '-36 -36 -24', '36 36 50',
   7 /* model      */ "mage.dpm",
   8 /* netname    */ "mage",
   9 /* fullname   */ _("Mage")
  10 );
  11
  12 #define MAGE_SETTINGS(monster) \
  13         MON_ADD_CVAR(monster, health) \
  14         MON_ADD_CVAR(monster, attack_spike_damage) \
  15         MON_ADD_CVAR(monster, attack_spike_radius) \
  16         MON_ADD_CVAR(monster, attack_spike_delay) \
  17         MON_ADD_CVAR(monster, attack_spike_accel) \
  18         MON_ADD_CVAR(monster, attack_spike_decel) \
  19         MON_ADD_CVAR(monster, attack_spike_turnrate) \
  20         MON_ADD_CVAR(monster, attack_spike_speed_max) \
  21         MON_ADD_CVAR(monster, attack_spike_smart) \
  22         MON_ADD_CVAR(monster, attack_spike_smart_trace_min) \
  23         MON_ADD_CVAR(monster, attack_spike_smart_trace_max) \
  24         MON_ADD_CVAR(monster, attack_spike_smart_mindist) \
  25         MON_ADD_CVAR(monster, attack_melee_damage) \
  26         MON_ADD_CVAR(monster, attack_melee_delay) \
  27         MON_ADD_CVAR(monster, attack_grenade_damage) \
  28         MON_ADD_CVAR(monster, attack_grenade_edgedamage) \
  29         MON_ADD_CVAR(monster, attack_grenade_force) \
  30         MON_ADD_CVAR(monster, attack_grenade_radius) \
  31         MON_ADD_CVAR(monster, attack_grenade_lifetime) \
  32         MON_ADD_CVAR(monster, attack_grenade_chance) \
  33         MON_ADD_CVAR(monster, attack_grenade_speed) \
  34         MON_ADD_CVAR(monster, attack_grenade_speed_up) \
  35         MON_ADD_CVAR(monster, heal_self) \
  36         MON_ADD_CVAR(monster, heal_allies) \
  37         MON_ADD_CVAR(monster, heal_minhealth) \
  38         MON_ADD_CVAR(monster, heal_range) \
  39         MON_ADD_CVAR(monster, heal_delay) \
  40         MON_ADD_CVAR(monster, shield_time) \
  41         MON_ADD_CVAR(monster, shield_delay) \
  42         MON_ADD_CVAR(monster, shield_blockpercent) \
  43         MON_ADD_CVAR(monster, speed_stop) \
  44         MON_ADD_CVAR(monster, speed_run) \
  45         MON_ADD_CVAR(monster, speed_walk)
  46
  47 #ifdef SVQC
  48 MAGE_SETTINGS(mage)
  49 #endif // SVQC
  50 #else
  51 #ifdef SVQC
  52 const float mage_anim_idle              = 0;
  53 const float mage_anim_walk              = 1;
  54 const float mage_anim_attack    = 2;
  55 const float mage_anim_pain              = 3;
  56 const float mage_anim_death     = 4;
  57 const float mage_anim_run               = 5;
  58
  59 void() mage_heal;
  60 void() mage_shield;
  61
  62 float friend_needshelp(entity e)
  63 {
  64         if(e == world)
  65                 return FALSE;
  66         if(e.health <= 0)
  67                 return FALSE;
  68         if(vlen(e.origin - self.origin) > MON_CVAR(mage, heal_range))
  69                 return FALSE;
  70         if(IsDifferentTeam(e, self))
  71                 return FALSE;
  72         if(e.frozen)
  73                 return FALSE;
  74         if(!IS_PLAYER(e))
  75                 return (e.health < e.max_health);
  76         if(e.items & IT_INVINCIBLE)
  77                 return FALSE;
  78
  79         switch(self.skin)
  80         {
  81                 case 0: return (e.health < autocvar_g_balance_health_regenstable);
  82                 case 1: return ((e.ammo_cells && e.ammo_cells < g_pickup_cells_max) || (e.ammo_rockets && e.ammo_rockets < g_pickup_rockets_max) || (e.ammo_nails && e.ammo_nails < g_pickup_nails_max) || (e.ammo_shells && e.ammo_shells < g_pickup_shells_max));
  83                 case 2: return (e.armorvalue < autocvar_g_balance_armor_regenstable);
  84                 case 3: return (e.health > 0);
  85         }
  86
  87         return FALSE;
  88 }
  89
  90 void mageattack_melee()
  91 {
  92         monster_melee(self.enemy, MON_CVAR(mage, attack_melee_damage), mage_anim_attack, self.attack_range, MON_CVAR(mage, attack_melee_delay) - 0.2, DEATH_MONSTER_MAGE, TRUE);
  93 }
  94
  95 void mage_grenade_explode()
  96 {
  97         pointparticles(particleeffectnum("explosion_small"), self.origin, '0 0 0', 1);
  98
  99         sound(self, CH_SHOTS, "weapons/grenade_impact.wav", VOL_BASE, ATTEN_NORM);
 100         RadiusDamage (self, self.realowner, MON_CVAR(mage, attack_grenade_damage), MON_CVAR(mage, attack_grenade_edgedamage), MON_CVAR(mage, attack_grenade_radius), world, MON_CVAR(mage, attack_grenade_force), DEATH_MONSTER_MAGE, other);
 101         remove(self);
 102 }
 103
 104 void mage_grenade_touch()
 105 {
 106         if(IS_PLAYER(other))
 107         {
 108                 PROJECTILE_TOUCH;
 109                 mage_grenade_explode();
 110                 return;
 111         }
 112 }
 113
 114 void mage_throw_itemgrenade()
 115 {
 116         makevectors(self.angles);
 117
 118         entity gren = spawn ();
 119         gren.owner = gren.realowner = self;
 120         gren.classname = "grenade";
 121         gren.bot_dodge = FALSE;
 122         gren.movetype = MOVETYPE_BOUNCE;
 123         gren.solid = SOLID_TRIGGER;
 124         gren.projectiledeathtype = DEATH_MONSTER_MAGE;
 125         setorigin(gren, CENTER_OR_VIEWOFS(self));
 126         setsize(gren, '-64 -64 -64', '64 64 64');
 127
 128         gren.nextthink = time + MON_CVAR(mage, attack_grenade_lifetime);
 129         gren.think = mage_grenade_explode;
 130         gren.use = mage_grenade_explode;
 131         gren.touch = mage_grenade_touch;
 132
 133         gren.missile_flags = MIF_SPLASH | MIF_ARC;
 134         W_SetupProjectileVelocityEx(gren, v_forward, v_up, MON_CVAR(mage, attack_grenade_speed), MON_CVAR(mage, attack_grenade_speed_up), 0, 0, FALSE);
 135
 136         gren.flags = FL_PROJECTILE;
 137
 138         setmodel(gren, "models/items/g_h50.md3");
 139
 140         self.attack_finished_single = time + 1.5;
 141 }
 142
 143 void mage_spike_explode()
 144 {
 145         self.event_damage = func_null;
 146
 147         sound(self, CH_SHOTS, "weapons/grenade_impact.wav", VOL_BASE, ATTEN_NORM);
 148
 149         pointparticles(particleeffectnum("explosion_small"), self.origin, '0 0 0', 1);
 150         RadiusDamage (self, self.realowner, MON_CVAR(mage, attack_spike_damage), MON_CVAR(mage, attack_spike_damage) * 0.5, MON_CVAR(mage, attack_spike_radius), world, 0, DEATH_MONSTER_MAGE, other);
 151
 152         remove (self);
 153 }
 154
 155 void mage_spike_touch()
 156 {
 157         PROJECTILE_TOUCH;
 158
 159         mage_spike_explode();
 160 }
 161
 162 // copied from W_Seeker_Think
 163 void mage_spike_think()
 164 {
 165         entity e;
 166         vector desireddir, olddir, newdir, eorg;
 167         float turnrate;
 168         float dist;
 169         float spd;
 170
 171         if (time > self.ltime || self.enemy.health <= 0 || self.owner.health <= 0)
 172         {
 173                 self.projectiledeathtype |= HITTYPE_SPLASH;
 174                 mage_spike_explode();
 175         }
 176
 177         spd = vlen(self.velocity);
 178         spd = bound(
 179                 spd - MON_CVAR(mage, attack_spike_decel) * frametime,
 180                 MON_CVAR(mage, attack_spike_speed_max),
 181                 spd + MON_CVAR(mage, attack_spike_accel) * frametime
 182         );
 183
 184         if (self.enemy != world)
 185                 if (self.enemy.takedamage != DAMAGE_AIM || self.enemy.deadflag != DEAD_NO)
 186                         self.enemy = world;
 187
 188         if (self.enemy != world)
 189         {
 190                 e               = self.enemy;
 191                 eorg            = 0.5 * (e.absmin + e.absmax);
 192                 turnrate        = MON_CVAR(mage, attack_spike_turnrate); // how fast to turn
 193                 desireddir      = normalize(eorg - self.origin);
 194                 olddir          = normalize(self.velocity); // get my current direction
 195                 dist            = vlen(eorg - self.origin);
 196
 197                 // Do evasive maneuvers for world objects? ( this should be a cpu hog. :P )
 198                 if (MON_CVAR(mage, attack_spike_smart) && (dist > MON_CVAR(mage, attack_spike_smart_mindist)))
 199                 {
 200                         // Is it a better idea (shorter distance) to trace to the target itself?
 201                         if ( vlen(self.origin + olddir * self.wait) < dist)
 202                                 traceline(self.origin, self.origin + olddir * self.wait, FALSE, self);
 203                         else
 204                                 traceline(self.origin, eorg, FALSE, self);
 205
 206                         // Setup adaptive tracelength
 207                         self.wait = bound(MON_CVAR(mage, attack_spike_smart_trace_min), vlen(self.origin - trace_endpos), self.wait = MON_CVAR(mage, attack_spike_smart_trace_max));
 208
 209                         // Calc how important it is that we turn and add this to the desierd (enemy) dir.
 210                         desireddir  = normalize(((trace_plane_normal * (1 - trace_fraction)) + (desireddir * trace_fraction)) * 0.5);
 211                 }
 212
 213                 newdir = normalize(olddir + desireddir * turnrate); // take the average of the 2 directions; not the best method but simple & easy
 214                 self.velocity = newdir * spd; // make me fly in the new direction at my flight speed
 215         }
 216         else
 217                 dist = 0;
 218
 219         ///////////////
 220
 221         //self.angles = vectoangles(self.velocity);                     // turn model in the new flight direction
 222         self.nextthink = time;// + 0.05; // csqc projectiles
 223         UpdateCSQCProjectile(self);
 224 }
 225
 226 void mage_spike()
 227 {
 228         entity missile;
 229         vector dir = normalize((self.enemy.origin + '0 0 10') - self.origin);
 230
 231         makevectors(self.angles);
 232
 233         missile = spawn ();
 234         missile.owner = missile.realowner = self;
 235         missile.think = mage_spike_think;
 236         missile.ltime = time + 7;
 237         missile.nextthink = time;
 238         missile.solid = SOLID_BBOX;
 239         missile.movetype = MOVETYPE_FLYMISSILE;
 240         missile.flags = FL_PROJECTILE;
 241         setorigin(missile, self.origin + v_forward * 14 + '0 0 30' + v_right * -14);
 242         setsize (missile, '0 0 0', '0 0 0');
 243         missile.velocity = dir * 400;
 244         missile.avelocity = '300 300 300';
 245         missile.enemy = self.enemy;
 246         missile.touch = mage_spike_touch;
 247
 248         CSQCProjectile(missile, TRUE, PROJECTILE_MAGE_SPIKE, TRUE);
 249 }
 250
 251 void mage_heal()
 252 {
 253         entity head;
 254         float washealed = FALSE;
 255
 256         for(head = world; (head = findfloat(head, monster_attack, TRUE)); ) if(friend_needshelp(head))
 257         {
 258                 washealed = TRUE;
 259                 string fx = "";
 260                 if(IS_PLAYER(head))
 261                 {
 262                         switch(self.skin)
 263                         {
 264                                 case 0:
 265                                         if(head.health < autocvar_g_balance_health_regenstable) head.health = bound(0, head.health + MON_CVAR(mage, heal_allies), autocvar_g_balance_health_regenstable);
 266                                         fx = "healing_fx";
 267                                         break;
 268                                 case 1:
 269                                         if(head.ammo_cells) head.ammo_cells = bound(head.ammo_cells, head.ammo_cells + 1, g_pickup_cells_max);
 270                                         if(head.ammo_rockets) head.ammo_rockets = bound(head.ammo_rockets, head.ammo_rockets + 1, g_pickup_rockets_max);
 271                                         if(head.ammo_shells) head.ammo_shells = bound(head.ammo_shells, head.ammo_shells + 2, g_pickup_shells_max);
 272                                         if(head.ammo_nails) head.ammo_nails = bound(head.ammo_nails, head.ammo_nails + 5, g_pickup_nails_max);
 273                                         fx = "ammoregen_fx";
 274                                         break;
 275                                 case 2:
 276                                         if(head.armorvalue < autocvar_g_balance_armor_regenstable)
 277                                         {
 278                                                 head.armorvalue = bound(0, head.armorvalue + MON_CVAR(mage, heal_allies), autocvar_g_balance_armor_regenstable);
 279                                                 fx = "armorrepair_fx";
 280                                         }
 281                                         break;
 282                                 case 3:
 283                                         head.health = bound(0, head.health - ((head == self)  ? MON_CVAR(mage, heal_self) : MON_CVAR(mage, heal_allies)), autocvar_g_balance_health_regenstable);
 284                                         fx = "rage";
 285                                         break;
 286                         }
 287
 288                         pointparticles(particleeffectnum(fx), head.origin, '0 0 0', 1);
 289                 }
 290                 else
 291                 {
 292                         pointparticles(particleeffectnum("healing_fx"), head.origin, '0 0 0', 1);
 293                         head.health = bound(0, head.health + MON_CVAR(mage, heal_allies), head.max_health);
 294                         head.SendFlags |= MSF_STATUS;
 295                 }
 296         }
 297
 298         if(washealed)
 299         {
 300                 monsters_setframe(mage_anim_attack);
 301                 self.attack_finished_single = time + MON_CVAR(mage, heal_delay);
 302         }
 303 }
 304
 305 void mage_shield_think()
 306 {
 307         self.nextthink = time;
 308
 309         if(time >= self.ltime || self.owner.health <= 0)
 310         {
 311                 self.owner.armorvalue = 0;
 312                 self.owner.m_armor_blockpercent = autocvar_g_monsters_armor_blockpercent;
 313                 remove(self);
 314                 return;
 315         }
 316 }
 317
 318 void mage_shield()
 319 {
 320         if(self.weaponentity)
 321                 return; // already have a shield
 322
 323         entity shield = spawn();
 324
 325         shield.owner = self;
 326         shield.team = self.team;
 327         shield.ltime = time + MON_CVAR(mage, shield_time);
 328         shield.classname = "shield";
 329         shield.effects = EF_ADDITIVE;
 330         shield.movetype = MOVETYPE_NOCLIP;
 331         shield.solid = SOLID_TRIGGER;
 332         shield.avelocity = '7 0 11';
 333         shield.scale = self.scale * 0.6;
 334         shield.think = mage_shield_think;
 335         shield.nextthink = time;
 336
 337         setattachment(shield, self, "");
 338         setmodel(shield, "models/ctf/shield.md3");
 339         setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
 340
 341         self.lastshielded = time + MON_CVAR(mage, shield_delay);
 342
 343         monsters_setframe(mage_anim_attack);
 344         self.attack_finished_single = time + 1;
 345
 346         self.m_armor_blockpercent = MON_CVAR(mage, shield_blockpercent);
 347         self.armorvalue = self.health;
 348 }
 349
 350 float mage_attack(float attack_type)
 351 {
 352         switch(attack_type)
 353         {
 354                 case MONSTER_ATTACK_MELEE:
 355                 {
 356                         monsters_setframe(mage_anim_attack);
 357                         self.attack_finished_single = time + MON_CVAR(mage, attack_melee_delay);
 358                         defer(0.2, mageattack_melee);
 359
 360                         return TRUE;
 361                 }
 362                 case MONSTER_ATTACK_RANGED:
 363                 {
 364                         if(random() < MON_CVAR(mage, attack_grenade_chance) / 100)
 365                         {
 366                                 mage_throw_itemgrenade();
 367                                 return TRUE;
 368                         }
 369
 370                         monsters_setframe(mage_anim_attack);
 371                         self.attack_finished_single = time + MON_CVAR(mage, attack_spike_delay);
 372                         defer(0.2, mage_spike);
 373
 374                         return TRUE;
 375                 }
 376         }
 377
 378         return FALSE;
 379 }
 380
 381 void spawnfunc_monster_mage()
 382 {
 383         self.classname = "monster_mage";
 384
 385         self.monster_spawnfunc = spawnfunc_monster_mage;
 386
 387         if(Monster_CheckAppearFlags(self))
 388                 return;
 389
 390         if not(monster_initialize(MON_MAGE, FALSE)) { remove(self); return; }
 391 }
 392
 393 // compatibility with old spawns
 394 void spawnfunc_monster_shalrath() { spawnfunc_monster_mage(); }
 395
 396 float m_mage(float req)
 397 {
 398         switch(req)
 399         {
 400                 case MR_THINK:
 401                 {
 402                         entity head;
 403                         float need_help = FALSE;
 404
 405                         FOR_EACH_PLAYER(head)
 406                         if(friend_needshelp(head))
 407                         {
 408                                 need_help = TRUE;
 409                                 break; // found 1 player near us who is low on health
 410                         }
 411                         if(!need_help)
 412                         FOR_EACH_MONSTER(head)
 413                         if(head != self)
 414                         if(friend_needshelp(head))
 415                         {
 416                                 need_help = TRUE;
 417                                 break; // found 1 player near us who is low on health
 418                         }
 419
 420                         if(self.health < MON_CVAR(mage, heal_minhealth) || need_help)
 421                         if(time >= self.attack_finished_single)
 422                         if(random() < 0.5)
 423                                 mage_heal();
 424
 425                         if(self.enemy)
 426                         if(self.health < self.max_health)
 427                         if(time >= self.lastshielded)
 428                         if(random() < 0.5)
 429                                 mage_shield();
 430
 431                         monster_move(MON_CVAR(mage, speed_run), MON_CVAR(mage, speed_walk), MON_CVAR(mage, speed_stop), mage_anim_walk, mage_anim_run, mage_anim_idle);
 432                         return TRUE;
 433                 }
 434                 case MR_DEATH:
 435                 {
 436                         monsters_setframe(mage_anim_death);
 437                         return TRUE;
 438                 }
 439                 case MR_SETUP:
 440                 {
 441                         if not(self.health) self.health = MON_CVAR(mage, health);
 442
 443                         self.monster_loot = spawnfunc_item_health_large;
 444                         self.monster_attackfunc = mage_attack;
 445                         monsters_setframe(mage_anim_walk);
 446
 447                         return TRUE;
 448                 }
 449                 case MR_INIT:
 450                 {
 451                         precache_model ("models/items/g_h50.md3");
 452                         precache_model ("models/ctf/shield.md3");
 453                         precache_sound ("weapons/grenade_impact.wav");
 454                         return TRUE;
 455                 }
 456                 case MR_CONFIG:
 457                 {
 458                         MON_CONFIG_SETTINGS(MAGE_SETTINGS(mage))
 459                         return TRUE;
 460                 }
 461         }
 462
 463         return TRUE;
 464 }
 465
 466 #endif // SVQC
 467 #ifdef CSQC
 468 float m_mage(float req)
 469 {
 470         switch(req)
 471         {
 472                 case MR_DEATH:
 473                 {
 474                         // nothing
 475                         return TRUE;
 476                 }
 477                 case MR_INIT:
 478                 {
 479                         precache_model ("models/monsters/mage.dpm");
 480                         return TRUE;
 481                 }
 482         }
 483
 484         return TRUE;
 485 }
 486
 487 #endif // CSQC
 488 #endif // REGISTER_MONSTER