qcsrc/common/turrets/unit/hk.qc

   1 #ifdef REGISTER_TURRET
   2 REGISTER_TURRET(
   3 /* TUR_##id   */ HK,
   4 /* function   */ t_hk,
   5 /* spawnflags */ TUR_FLAG_SPLASH | TUR_FLAG_MEDPROJ | TUR_FLAG_PLAYER | TUR_FLAG_RECIEVETARGETS,
   6 /* mins,maxs  */ '-32 -32 0', '32 32 64',
   7 /* model          */ "base.md3",
   8 /* head_model */ "hk.md3",
   9 /* netname        */ "hk",
  10 /* fullname   */ _("Hunter-Killer Turret")
  11 );
  12
  13 #define HK_SETTINGS(turret) \
  14         TUR_ADD_CVAR(turret, shot_speed) \
  15         TUR_ADD_CVAR(turret, shot_speed_accel) \
  16         TUR_ADD_CVAR(turret, shot_speed_accel2) \
  17         TUR_ADD_CVAR(turret, shot_speed_decel) \
  18         TUR_ADD_CVAR(turret, shot_speed_max) \
  19         TUR_ADD_CVAR(turret, shot_speed_turnrate)
  20
  21
  22 #ifdef SVQC
  23 HK_SETTINGS(hk)
  24 #endif // SVQC
  25 #else
  26 #ifdef SVQC
  27
  28 //#define TURRET_DEBUG_HK
  29
  30 #ifdef TURRET_DEBUG_HK
  31 .float atime;
  32 #endif
  33
  34 float hk_is_valid_target(entity e_target)
  35 {
  36         if (e_target == world)
  37                 return 0;
  38
  39         // If only this was used more..
  40         if (e_target.flags & FL_NOTARGET)
  41                 return 0;
  42
  43         // Cant touch this
  44         if ((e_target.takedamage == DAMAGE_NO) || (e_target.health < 0))
  45                 return 0;
  46
  47         // player
  48         if (IS_CLIENT(e_target))
  49         {
  50                 if (self.owner.target_select_playerbias < 0)
  51                         return 0;
  52
  53                 if (e_target.deadflag != DEAD_NO)
  54                         return 0;
  55         }
  56
  57         // Missile
  58         if ((e_target.flags & FL_PROJECTILE) && (self.owner.target_select_missilebias < 0))
  59                 return 0;
  60
  61         // Team check
  62         if ((e_target.team == self.owner.team) || (self.owner.team == e_target.owner.team))
  63                 return 0;
  64
  65         return 1;
  66 }
  67
  68 void turret_hk_missile_think()
  69 {
  70         vector vu, vd, vf, vl, vr, ve;  // Vector (direction)
  71         float  fu, fd, ff, fl, fr, fe;  // Fraction to solid
  72         vector olddir,wishdir,newdir;   // Final direction
  73         float lt_for;   // Length of Trace FORwrad
  74         float lt_seek;  // Length of Trace SEEK (left, right, up down)
  75         float pt_seek;  // Pitch of Trace SEEK (How mutch to angele left, right up, down trace towards v_forward)
  76         vector pre_pos;
  77         float myspeed;
  78         entity e;
  79         float ad,edist;
  80
  81         self.nextthink = time + self.ticrate;
  82
  83         //if (self.cnt < time)
  84         //      turret_hk_missile_explode();
  85
  86         if (self.enemy.deadflag != DEAD_NO)
  87                 self.enemy = world;
  88
  89         // Pick the closest valid target.
  90         if (!self.enemy)
  91         {
  92                 e = findradius(self.origin, 5000);
  93                 while (e)
  94                 {
  95                         if (hk_is_valid_target(e))
  96                         {
  97                                 if (!self.enemy)
  98                                         self.enemy = e;
  99                                 else
 100                                         if (vlen(self.origin - e.origin) < vlen(self.origin - self.enemy.origin))
 101                                                 self.enemy = e;
 102                         }
 103                         e = e.chain;
 104                 }
 105         }
 106
 107         self.angles = vectoangles(self.velocity);
 108         self.angles_x = self.angles_x * -1;
 109         makevectors(self.angles);
 110         self.angles_x = self.angles_x * -1;
 111
 112         if (self.enemy)
 113         {
 114                 edist = vlen(self.origin - self.enemy.origin);
 115                 // Close enougth to do decent damage?
 116                 if ( edist <= (self.owner.shot_radius * 0.25) )
 117                 {
 118                         turret_projectile_explode();
 119                         return;
 120                 }
 121
 122                 // Get data on enemy position
 123                 pre_pos = self.enemy.origin +
 124                                   self.enemy.velocity *
 125                                   min((vlen(self.enemy.origin - self.origin) / vlen(self.velocity)),0.5);
 126
 127                 traceline(self.origin, pre_pos,TRUE,self.enemy);
 128                 ve = normalize(pre_pos - self.origin);
 129                 fe = trace_fraction;
 130
 131         }
 132         else
 133         {
 134         edist = 0;
 135         ve = '0 0 0';
 136                 fe = 0;
 137         }
 138
 139         if ((fe != 1) || (self.enemy == world) || (edist > 1000))
 140         {
 141                 myspeed = vlen(self.velocity);
 142
 143                 lt_for  = myspeed * 3;
 144                 lt_seek = myspeed * 2.95;
 145
 146                 // Trace forward
 147                 traceline(self.origin, self.origin + v_forward * lt_for,FALSE,self);
 148                 vf = trace_endpos;
 149                 ff = trace_fraction;
 150
 151                 // Find angular offset
 152                 ad = vlen(vectoangles(normalize(self.enemy.origin - self.origin)) - self.angles);
 153
 154                 // To close to something, Slow down!
 155                 if ( ((ff < 0.7) || (ad > 4)) && (myspeed > TUR_CVAR(hk, shot_speed)) )
 156                         myspeed = max(myspeed * TUR_CVAR(hk, shot_speed_decel), TUR_CVAR(hk, shot_speed));
 157
 158                 // Failry clear, accelerate.
 159                 if ( (ff > 0.7) && (myspeed < TUR_CVAR(hk, shot_speed_max)) )
 160                         myspeed = min(myspeed * TUR_CVAR(hk, shot_speed_accel), TUR_CVAR(hk, shot_speed_max));
 161
 162                 // Setup trace pitch
 163                 pt_seek = 1 - ff;
 164                 pt_seek = bound(0.15,pt_seek,0.8);
 165                 if (ff < 0.5) pt_seek = 1;
 166
 167                 // Trace left
 168                 traceline(self.origin, self.origin + (-1 * (v_right * pt_seek) + (v_forward * ff)) * lt_seek,FALSE,self);
 169                 vl = trace_endpos;
 170                 fl = trace_fraction;
 171
 172                 // Trace right
 173                 traceline(self.origin,  self.origin + ((v_right * pt_seek) + (v_forward * ff)) * lt_seek ,FALSE,self);
 174                 vr = trace_endpos;
 175                 fr = trace_fraction;
 176
 177                 // Trace up
 178                 traceline(self.origin,  self.origin + ((v_up * pt_seek) + (v_forward * ff)) * lt_seek ,FALSE,self);
 179                 vu = trace_endpos;
 180                 fu = trace_fraction;
 181
 182                 // Trace down
 183                 traceline(self.origin,  self.origin + (-1 * (v_up * pt_seek) + (v_forward * ff)) * lt_seek ,FALSE,self);
 184                 vd = trace_endpos;
 185                 fd = trace_fraction;
 186
 187                 vl = normalize(vl - self.origin);
 188                 vr = normalize(vr - self.origin);
 189                 vu = normalize(vu - self.origin);
 190                 vd = normalize(vd - self.origin);
 191
 192                 // Panic tresh passed, find a single direction and turn as hard as we can
 193                 if (pt_seek == 1)
 194                 {
 195                         wishdir = v_right;
 196                         if (fl > fr) wishdir = -1 * v_right;
 197                         if (fu > fl) wishdir = v_up;
 198                         if (fd > fu) wishdir = -1 * v_up;
 199                 }
 200                 else
 201                 {
 202                         // Normalize our trace vectors to make a smooth path
 203                         wishdir = normalize( (vl * fl) + (vr * fr) +  (vu * fu) +  (vd * fd) );
 204                 }
 205
 206                 if (self.enemy)
 207                 {
 208                         if (fe < 0.1) fe = 0.1; // Make sure we always try to move sligtly towards our target
 209                         wishdir = (wishdir * (1 - fe)) + (ve * fe);
 210                 }
 211         }
 212         else
 213         {
 214                 // Got a clear path to target, speed up fast (if not at full speed) and go straight for it.
 215                 myspeed = vlen(self.velocity);
 216                 if (myspeed < TUR_CVAR(hk, shot_speed_max))
 217                         myspeed = min(myspeed * TUR_CVAR(hk, shot_speed_accel2),TUR_CVAR(hk, shot_speed_max));
 218
 219                 wishdir = ve;
 220         }
 221
 222         if ((myspeed > TUR_CVAR(hk, shot_speed)) && (self.cnt > time))
 223                 myspeed = min(myspeed * TUR_CVAR(hk, shot_speed_accel2),TUR_CVAR(hk, shot_speed_max));
 224
 225         // Ranoutagazfish?
 226         if (self.cnt < time)
 227         {
 228                 self.cnt = time + 0.25;
 229                 self.nextthink = 0;
 230                 self.movetype            = MOVETYPE_BOUNCE;
 231                 return;
 232         }
 233
 234         // Calculate new heading
 235         olddir = normalize(self.velocity);
 236         newdir = normalize(olddir + wishdir * TUR_CVAR(hk, shot_speed_turnrate));
 237
 238         // Set heading & speed
 239         self.velocity = newdir * myspeed;
 240
 241         // Align model with new heading
 242         self.angles = vectoangles(self.velocity);
 243
 244
 245 #ifdef TURRET_DEBUG_HK
 246         //if(self.atime < time) {
 247         if ((fe <= 0.99)||(edist > 1000))
 248         {
 249                 te_lightning2(world,self.origin, self.origin + vr * lt_seek);
 250                 te_lightning2(world,self.origin, self.origin + vl * lt_seek);
 251                 te_lightning2(world,self.origin, self.origin + vu * lt_seek);
 252                 te_lightning2(world,self.origin, self.origin + vd * lt_seek);
 253                 te_lightning2(world,self.origin, vf);
 254         }
 255         else
 256         {
 257                 te_lightning2(world,self.origin, self.enemy.origin);
 258         }
 259         bprint("Speed: ", ftos(rint(myspeed)), "\n");
 260         bprint("Trace to solid: ", ftos(rint(ff * 100)), "%\n");
 261         bprint("Trace to target:", ftos(rint(fe * 100)), "%\n");
 262         self.atime = time + 0.2;
 263         //}
 264 #endif
 265
 266         UpdateCSQCProjectile(self);
 267 }
 268
 269 float turret_hk_addtarget(entity e_target,entity e_sender)
 270 {
 271         if (e_target)
 272         {
 273                 if (turret_validate_target(self,e_target,self.target_validate_flags) > 0)
 274                 {
 275                         self.enemy = e_target;
 276                         return 1;
 277                 }
 278         }
 279
 280         return 0;
 281 }
 282
 283 void spawnfunc_turret_hk() { if not(turret_initialize(TUR_HK)) remove(self); }
 284
 285 float t_hk(float req)
 286 {
 287         switch(req)
 288         {
 289                 case TR_ATTACK:
 290                 {
 291                         entity missile;
 292
 293                         missile = turret_projectile("weapons/rocket_fire.wav", 6, 10, DEATH_TURRET_HK, PROJECTILE_ROCKET, FALSE, FALSE);
 294                         te_explosion (missile.origin);
 295
 296                         missile.think                   = turret_hk_missile_think;
 297                         missile.nextthink               = time + 0.25;
 298                         missile.movetype                 = MOVETYPE_BOUNCEMISSILE;
 299                         missile.velocity                 = self.tur_shotdir_updated * (self.shot_speed * 0.75);
 300                         missile.angles             = vectoangles(missile.velocity);
 301                         missile.cnt                       = time + 30;
 302                         missile.ticrate           = max(autocvar_sys_ticrate, 0.05);
 303                         missile.missile_flags = MIF_SPLASH | MIF_PROXY | MIF_GUIDED_AI;
 304
 305                         if (self.tur_head.frame == 0)
 306                                 self.tur_head.frame = self.tur_head.frame + 1;
 307
 308                         return TRUE;
 309                 }
 310                 case TR_THINK:
 311                 {
 312                         if (self.tur_head.frame != 0)
 313                                 self.tur_head.frame = self.tur_head.frame + 1;
 314
 315                         if (self.tur_head.frame > 5)
 316                                 self.tur_head.frame = 0;
 317
 318                         return TRUE;
 319                 }
 320                 case TR_DEATH:
 321                 {
 322                         return TRUE;
 323                 }
 324                 case TR_SETUP:
 325                 {
 326                         self.ammo_flags = TFL_AMMO_ROCKETS | TFL_AMMO_RECHARGE;
 327                         self.aim_flags = TFL_AIM_SIMPLE;
 328                         self.target_select_flags = TFL_TARGETSELECT_LOS | TFL_TARGETSELECT_PLAYERS | TFL_TARGETSELECT_TRIGGERTARGET | TFL_TARGETSELECT_RANGELIMITS | TFL_TARGETSELECT_TEAMCHECK;
 329                         self.firecheck_flags = TFL_FIRECHECK_DEAD | TFL_FIRECHECK_TEAMCHECK  | TFL_FIRECHECK_REFIRE | TFL_FIRECHECK_AFF;
 330                         self.shoot_flags = TFL_SHOOT_CLEARTARGET;
 331                         self.target_validate_flags = TFL_TARGETSELECT_PLAYERS | TFL_TARGETSELECT_TEAMCHECK;
 332
 333                         self.turret_addtarget = turret_hk_addtarget;
 334
 335                         return TRUE;
 336                 }
 337                 case TR_PRECACHE:
 338                 {
 339                         precache_model ("models/turrets/base.md3");
 340                         precache_model ("models/turrets/hk.md3");
 341                         return TRUE;
 342                 }
 343                 case TR_CONFIG:
 344                 {
 345                         TUR_CONFIG_SETTINGS(HK_SETTINGS(hk))
 346                         return TRUE;
 347                 }
 348         }
 349
 350         return TRUE;
 351 }
 352
 353 #endif // SVQC
 354 #ifdef CSQC
 355 float t_hk(float req)
 356 {
 357         switch(req)
 358         {
 359                 case TR_SETUP:
 360                 {
 361                         return TRUE;
 362                 }
 363                 case TR_PRECACHE:
 364                 {
 365                         precache_model ("models/turrets/base.md3");
 366                         precache_model ("models/turrets/hk.md3");
 367                         return TRUE;
 368                 }
 369         }
 370
 371         return TRUE;
 372 }
 373
 374 #endif // CSQC
 375 #endif // REGISTER_TURRET