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