qcsrc/common/monsters/monster/knight.qc

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