qcsrc/server/monsters/monster/knight.qc

   1 // size
   2 const vector KNIGHT_MIN = '-20 -20 -32';
   3 const vector KNIGHT_MAX = '20 20 41';
   4
   5 // model
   6 string KNIGHT_MODEL = "models/monsters/hknight.mdl";
   7
   8 #ifdef SVQC
   9 // cvars
  10 float autocvar_g_monster_knight;
  11 float autocvar_g_monster_knight_health;
  12 float autocvar_g_monster_knight_melee_damage;
  13 float autocvar_g_monster_knight_inferno_damage;
  14 float autocvar_g_monster_knight_inferno_damagetime;
  15 float autocvar_g_monster_knight_inferno_chance;
  16 float autocvar_g_monster_knight_speed_walk;
  17 float autocvar_g_monster_knight_speed_run;
  18 float autocvar_g_monster_knight_fireball_damage;
  19 float autocvar_g_monster_knight_fireball_force;
  20 float autocvar_g_monster_knight_fireball_radius;
  21 float autocvar_g_monster_knight_fireball_chance;
  22 float autocvar_g_monster_knight_fireball_edgedamage;
  23 float autocvar_g_monster_knight_spike_chance;
  24 float autocvar_g_monster_knight_spike_force;
  25 float autocvar_g_monster_knight_spike_radius;
  26 float autocvar_g_monster_knight_spike_edgedamage;
  27 float autocvar_g_monster_knight_spike_damage;
  28 float autocvar_g_monster_knight_jump_chance;
  29 float autocvar_g_monster_knight_jump_damage;
  30 float autocvar_g_monster_knight_jump_dist;
  31
  32 // animations
  33 const float knight_anim_stand   = 0;
  34 const float knight_anim_walk    = 1;
  35 const float knight_anim_run     = 2;
  36 const float knight_anim_pain    = 3;
  37 const float knight_anim_death1  = 4;
  38 const float knight_anim_death2  = 5;
  39 const float knight_anim_charge1 = 6;
  40 const float knight_anim_magic1  = 7;
  41 const float knight_anim_magic2  = 8;
  42 const float knight_anim_charge2 = 9;
  43 const float knight_anim_slice   = 10;
  44 const float knight_anim_smash   = 11;
  45 const float knight_anim_wattack = 12;
  46 const float knight_anim_magic3  = 13;
  47
  48 .float knight_cycles;
  49
  50 void knight_think()
  51 {
  52         self.think = knight_think;
  53         self.nextthink = time + self.ticrate;
  54
  55         monster_move(autocvar_g_monster_knight_speed_run, autocvar_g_monster_knight_speed_walk, 100, knight_anim_run, knight_anim_walk, knight_anim_stand);
  56 }
  57
  58 void knight_inferno()
  59 {
  60         self.monster_delayedattack = func_null;
  61         self.delay = -1;
  62         if not(self.enemy)
  63                 return;
  64
  65         traceline((self.absmin + self.absmax) * 0.5, (self.enemy.absmin + self.enemy.absmax) * 0.5, TRUE, world);
  66         if (trace_fraction != 1)
  67                 return; // not visible
  68
  69         self.enemy.effects |= EF_MUZZLEFLASH;
  70         sound(self.enemy, CHAN_AUTO, "player/lava.wav", 1, ATTN_NORM);
  71
  72         if(vlen(self.enemy.origin - self.origin) <= 2000)
  73                 Fire_AddDamage(self.enemy, self, autocvar_g_monster_knight_inferno_damage * monster_skill, autocvar_g_monster_knight_inferno_damagetime, DEATH_MONSTER_KNIGHT_INFERNO);
  74 }
  75
  76 void knight_fireball_explode()
  77 {
  78         entity e;
  79         if(self)
  80         {
  81                 pointparticles(particleeffectnum("fireball_explode"), self.origin, '0 0 0', 1);
  82
  83                 RadiusDamage(self, self.realowner, autocvar_g_monster_knight_fireball_damage, autocvar_g_monster_knight_fireball_edgedamage, autocvar_g_monster_knight_fireball_force, world, autocvar_g_monster_knight_fireball_radius, self.projectiledeathtype, world);
  84
  85                 for(e = world; (e = findfloat(e, takedamage, DAMAGE_AIM)); ) if(vlen(e.origin - self.origin) <= autocvar_g_monster_knight_fireball_radius)
  86                         Fire_AddDamage(e, self, 5 * monster_skill, autocvar_g_monster_knight_inferno_damagetime, self.projectiledeathtype);
  87
  88                 remove(self);
  89         }
  90 }
  91
  92 void knight_fireball_touch()
  93 {
  94         PROJECTILE_TOUCH;
  95
  96         knight_fireball_explode();
  97 }
  98
  99 void knight_fireball()
 100 {
 101         entity missile = spawn();
 102         vector dir = normalize((self.enemy.origin + '0 0 10') - self.origin);
 103
 104         monster_makevectors(self.enemy);
 105
 106         self.monster_delayedattack = func_null;
 107         self.delay = -1;
 108
 109         self.effects |= EF_MUZZLEFLASH;
 110         sound(self, CHAN_WEAPON, "weapons/fireball2.wav", 1, ATTN_NORM);
 111
 112         missile.owner = missile.realowner = self;
 113         missile.solid = SOLID_TRIGGER;
 114         missile.movetype = MOVETYPE_FLYMISSILE;
 115         missile.projectiledeathtype = DEATH_MONSTER_KNIGHT_FBALL;
 116         setsize(missile, '-6 -6 -6', '6 6 6');
 117         setorigin(missile, self.origin + self.view_ofs + v_forward * 14);
 118         missile.flags = FL_PROJECTILE;
 119         missile.velocity = dir * 400;
 120         missile.avelocity = '300 300 300';
 121         missile.nextthink = time + 5;
 122         missile.think = knight_fireball_explode;
 123         missile.enemy = self.enemy;
 124         missile.touch = knight_fireball_touch;
 125         CSQCProjectile(missile, TRUE, PROJECTILE_FIREMINE, TRUE);
 126 }
 127
 128 void knight_spike_explode()
 129 {
 130         if(self)
 131         {
 132                 pointparticles(particleeffectnum("TE_WIZSPIKE"), self.origin, '0 0 0', 1);
 133
 134                 RadiusDamage (self, self.realowner, autocvar_g_monster_knight_spike_damage, autocvar_g_monster_knight_spike_edgedamage, autocvar_g_monster_knight_spike_force, world, autocvar_g_monster_knight_spike_radius, DEATH_MONSTER_KNIGHT_SPIKE, other);
 135                 remove(self);
 136         }
 137 }
 138
 139 void knight_spike_touch()
 140 {
 141         PROJECTILE_TOUCH;
 142
 143         knight_spike_explode();
 144 }
 145
 146 void knight_spike()
 147 {
 148         entity missile;
 149         vector dir = normalize((self.enemy.origin + '0 0 10') - self.origin);
 150
 151         self.effects |= EF_MUZZLEFLASH;
 152
 153         missile = spawn ();
 154         missile.owner = missile.realowner = self;
 155         missile.solid = SOLID_TRIGGER;
 156         missile.movetype = MOVETYPE_FLYMISSILE;
 157         setsize (missile, '0 0 0', '0 0 0');
 158         setorigin(missile, self.origin + '0 0 10' + v_forward * 14);
 159         missile.scale = self.scale;
 160         missile.flags = FL_PROJECTILE;
 161         missile.velocity = dir * 400;
 162         missile.avelocity = '300 300 300';
 163         missile.nextthink = time + 5;
 164         missile.think = knight_spike_explode;
 165         missile.enemy = self.enemy;
 166         missile.touch = knight_spike_touch;
 167         CSQCProjectile(missile, TRUE, PROJECTILE_CRYLINK, TRUE);
 168 }
 169
 170 void knight_spikes()
 171 {
 172         self.monster_delayedattack = knight_spikes;
 173         self.delay = time + 0.1;
 174         self.knight_cycles += 1;
 175         knight_spike();
 176         if(self.knight_cycles >= 7)
 177         {
 178                 self.monster_delayedattack = func_null;
 179                 self.delay = -1;
 180         }
 181 }
 182
 183 float knight_attack_ranged()
 184 {
 185         if not(self.flags & FL_ONGROUND)
 186                 return FALSE;
 187
 188         self.knight_cycles = 0;
 189
 190         RandomSelection_Init();
 191         RandomSelection_Add(world, 1, "", autocvar_g_monster_knight_fireball_chance, 1);
 192         RandomSelection_Add(world, 2, "", autocvar_g_monster_knight_inferno_chance, 1);
 193         RandomSelection_Add(world, 3, "", autocvar_g_monster_knight_spike_chance, 1);
 194         if(self.health >= 100) RandomSelection_Add(world, 4, "", ((vlen(self.enemy.origin - self.origin) > autocvar_g_monster_knight_jump_dist) ? 1 : autocvar_g_monster_knight_jump_chance), 1);
 195
 196         switch(RandomSelection_chosen_float)
 197         {
 198                 case 1:
 199                 {
 200                         monsters_setframe(knight_anim_magic2);
 201                         self.delay = time + 0.4;
 202                         self.monster_delayedattack = knight_fireball;
 203                         self.attack_finished_single = time + 2;
 204
 205                         return TRUE;
 206                 }
 207                 case 2:
 208                 {
 209                         self.monster_delayedattack = knight_inferno;
 210                         self.delay = time + 0.5;
 211                         self.attack_finished_single = time + 3;
 212                         return TRUE;
 213                 }
 214                 case 3:
 215                 {
 216                         monsters_setframe(knight_anim_magic3);
 217                         self.monster_delayedattack = knight_spikes;
 218                         self.delay = time + 0.4;
 219                         self.attack_finished_single = time + 3;
 220
 221                         return TRUE;
 222                 }
 223                 case 4:
 224                 {
 225                         float er = vlen(self.enemy.origin - self.origin);
 226
 227                         if(er >= 400 && er < 1200)
 228                         if(findtrajectorywithleading(self.origin, self.mins, self.maxs, self.enemy, 1000, 0, 10, 0, self))
 229                         {
 230                                 self.velocity = findtrajectory_velocity;
 231                                 Damage(self.enemy, self, self, autocvar_g_monster_knight_jump_damage * monster_skill, DEATH_MONSTER_KNIGHT_CRUSH, self.enemy.origin, normalize(self.enemy.origin - self.origin));
 232                                 self.attack_finished_single = time + 2;
 233                                 return TRUE;
 234                         }
 235                         return FALSE;
 236                 }
 237         }
 238
 239         return FALSE;
 240 }
 241
 242 float knight_attack(float attack_type)
 243 {
 244         switch(attack_type)
 245         {
 246                 case MONSTER_ATTACK_MELEE:
 247                 {
 248                         float anim;
 249                         if(random() < 0.3)
 250                                 anim = knight_anim_slice;
 251                         else if(random() < 0.6)
 252                                 anim = knight_anim_smash;
 253                         else
 254                                 anim = knight_anim_wattack;
 255
 256                         monsters_setframe(anim);
 257                         self.attack_finished_single = time + 0.7;
 258                         monster_melee(self.enemy, autocvar_g_monster_knight_melee_damage, 0.3, DEATH_MONSTER_KNIGHT_MELEE, TRUE);
 259
 260                         return TRUE;
 261                 }
 262                 case MONSTER_ATTACK_RANGED:
 263                 {
 264                         if(knight_attack_ranged())
 265                                 return TRUE;
 266                 }
 267         }
 268
 269         return FALSE;
 270 }
 271
 272 void knight_die()
 273 {
 274         float chance = random();
 275         Monster_CheckDropCvars ("knight");
 276
 277         self.think = monster_dead_think;
 278         self.nextthink = time + self.ticrate;
 279         self.ltime = time + 5;
 280         monsters_setframe((random() > 0.5) ? knight_anim_death1 : knight_anim_death2);
 281
 282         if(chance < 0.10 || self.flags & MONSTERFLAG_MINIBOSS)
 283         if(self.candrop)
 284         {
 285                 self.superweapons_finished = time + autocvar_g_balance_superweapons_time + 5; // give the player a few seconds to find the weapon
 286                 self.weapon = WEP_FIREBALL;
 287         }
 288
 289         monster_hook_death(); // for post-death mods
 290 }
 291
 292 void knight_spawn()
 293 {
 294         if not(self.health)
 295                 self.health = autocvar_g_monster_knight_health;
 296
 297         self.damageforcescale   = 0.003;
 298         self.classname                  = "monster_knight";
 299         self.monster_attackfunc = knight_attack;
 300         self.nextthink                  = time + random() * 0.5 + 0.1;
 301         self.think                              = knight_think;
 302
 303         monsters_setframe(knight_anim_stand);
 304
 305         monster_setupsounds("knight");
 306
 307         monster_hook_spawn(); // for post-spawn mods
 308 }
 309
 310 void spawnfunc_monster_knight()
 311 {
 312         if not(autocvar_g_monster_knight) { remove(self); return; }
 313
 314         self.monster_spawnfunc = spawnfunc_monster_knight;
 315
 316         if(Monster_CheckAppearFlags(self))
 317                 return;
 318
 319         self.scale = 1.3;
 320
 321         if not (monster_initialize(
 322                          "Knight", MONSTER_KNIGHT,
 323                          KNIGHT_MIN, KNIGHT_MAX,
 324                          FALSE,
 325                          knight_die, knight_spawn))
 326         {
 327                 remove(self);
 328                 return;
 329         }
 330 }
 331
 332 // compatibility with old spawns
 333 void spawnfunc_monster_hell_knight() { spawnfunc_monster_knight(); }
 334
 335 #endif // SVQC