qcsrc/common/vehicles/vehicle/racer_weapon.qc

   1 #ifndef VEHICLE_RACER_WEAPON_H
   2 #define VEHICLE_RACER_WEAPON_H
   3
   4 #include "../../weapons/all.qh"
   5
   6 CLASS(RacerAttack, PortoLaunch)
   7 /* flags     */ ATTRIB(RacerAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN);
   8 /* impulse   */ ATTRIB(RacerAttack, impulse, int, 3);
   9 /* refname   */ ATTRIB(RacerAttack, netname, string, "racercannon");
  10 /* wepname   */ ATTRIB(RacerAttack, message, string, _("Racer cannon"));
  11 ENDCLASS(RacerAttack)
  12 REGISTER_WEAPON(RACER, NEW(RacerAttack));
  13
  14 // TODO: move into implementation
  15 #ifdef SVQC
  16 float autocvar_g_vehicle_racer_rocket_refire;
  17 void racer_fire_rocket(vector org, vector dir, entity trg);
  18 #endif
  19
  20 #endif
  21
  22 #ifdef IMPLEMENTATION
  23
  24 #ifdef SVQC
  25
  26 float autocvar_g_vehicle_racer_cannon_cost;
  27 float autocvar_g_vehicle_racer_cannon_damage;
  28 float autocvar_g_vehicle_racer_cannon_radius;
  29 float autocvar_g_vehicle_racer_cannon_refire;
  30 float autocvar_g_vehicle_racer_cannon_speed;
  31 float autocvar_g_vehicle_racer_cannon_spread;
  32 float autocvar_g_vehicle_racer_cannon_force;
  33
  34 float autocvar_g_vehicle_racer_rocket_accel;
  35 float autocvar_g_vehicle_racer_rocket_damage;
  36 float autocvar_g_vehicle_racer_rocket_radius;
  37 float autocvar_g_vehicle_racer_rocket_force;
  38 float autocvar_g_vehicle_racer_rocket_speed;
  39 float autocvar_g_vehicle_racer_rocket_turnrate;
  40
  41 float autocvar_g_vehicle_racer_rocket_climbspeed;
  42 float autocvar_g_vehicle_racer_rocket_locked_maxangle;
  43
  44 void racer_fire_rocket(vector org, vector dir, entity trg);
  45 METHOD(RacerAttack, wr_think, void(entity thiswep, bool fire1, bool fire2))
  46 {
  47     SELFPARAM();
  48     bool isPlayer = IS_PLAYER(self);
  49     entity player = isPlayer ? self : self.owner;
  50     entity veh = player.vehicle;
  51     setself(player);
  52     if (fire1)
  53     if (weapon_prepareattack(false, autocvar_g_vehicle_racer_cannon_refire)) {
  54         if (veh) {
  55             veh.vehicle_energy -= autocvar_g_vehicle_racer_cannon_cost;
  56             veh.wait = time;
  57         }
  58         if (isPlayer) W_SetupShot_Dir(player, v_forward, false, 0, SND(Null), CH_WEAPON_B, 0);
  59         vector org = w_shotorg;
  60         vector dir = w_shotdir;
  61         entity bolt = vehicles_projectile(EFFECT_RACER_MUZZLEFLASH.eent_eff_name, SND(LASERGUN_FIRE),
  62                                org, normalize(v_forward + randomvec() * autocvar_g_vehicle_racer_cannon_spread) * autocvar_g_vehicle_racer_cannon_speed,
  63                                autocvar_g_vehicle_racer_cannon_damage, autocvar_g_vehicle_racer_cannon_radius, autocvar_g_vehicle_racer_cannon_force,  0,
  64                                DEATH_VH_WAKI_GUN, PROJECTILE_WAKICANNON, 0, true, true, player);
  65         bolt.velocity = normalize(dir) * autocvar_g_vehicle_racer_cannon_speed;
  66         weapon_thinkf(WFRAME_FIRE1, 0, w_ready);
  67     }
  68     if (fire2)
  69     if (!isPlayer || weapon_prepareattack(false, 0.2)) {
  70         if (isPlayer) W_SetupShot_Dir(self, v_forward, false, 0, SND(Null), CH_WEAPON_B, 0);
  71         racer_fire_rocket(w_shotorg, w_shotdir, NULL);
  72         weapon_thinkf(WFRAME_FIRE2, 0, w_ready);
  73     }
  74     setself(this);
  75 }
  76
  77 METHOD(RacerAttack, wr_checkammo1, bool(RacerAttack thiswep))
  78 {
  79     SELFPARAM();
  80     bool isPlayer = IS_PLAYER(self);
  81     entity player = isPlayer ? self : self.owner;
  82     entity veh = player.vehicle;
  83     return isPlayer || veh.vehicle_energy >= autocvar_g_vehicle_racer_cannon_cost;
  84 }
  85
  86 void racer_rocket_tracker();
  87 void racer_rocket_groundhugger();
  88
  89 void racer_fire_rocket(vector org, vector dir, entity trg)
  90 {SELFPARAM();
  91     entity rocket = vehicles_projectile(EFFECT_RACER_ROCKETLAUNCH.eent_eff_name, SND(ROCKET_FIRE),
  92                            org, dir * autocvar_g_vehicle_racer_rocket_speed,
  93                            autocvar_g_vehicle_racer_rocket_damage, autocvar_g_vehicle_racer_rocket_radius, autocvar_g_vehicle_racer_rocket_force, 3,
  94                            DEATH_VH_WAKI_ROCKET, PROJECTILE_WAKIROCKET, 20, false, false, self.owner);
  95
  96     rocket.lip                    = autocvar_g_vehicle_racer_rocket_accel * sys_frametime;
  97     rocket.wait                  = autocvar_g_vehicle_racer_rocket_turnrate;
  98     rocket.nextthink            = time;
  99     rocket.enemy                        = trg;
 100     rocket.cnt                    = time + 15;
 101
 102     if(trg)
 103         rocket.think                    = racer_rocket_tracker;
 104     else
 105         rocket.think                    = racer_rocket_groundhugger;
 106 }
 107
 108 void racer_rocket_tracker()
 109 {SELFPARAM();
 110     vector olddir, newdir;
 111     float oldvel, newvel;
 112
 113     self.nextthink  = time;
 114
 115     if (self.owner.deadflag != DEAD_NO || self.cnt < time)
 116     {
 117         self.use();
 118         return;
 119     }
 120
 121     if(!self.realowner.vehicle)
 122     {
 123         UpdateCSQCProjectile(self);
 124         return;
 125     }
 126
 127     olddir = normalize(self.velocity);
 128     oldvel = vlen(self.velocity);
 129     newvel = oldvel + self.lip;
 130     makevectors(vectoangles(olddir));
 131
 132     float time_to_impact = min(vlen(self.enemy.origin - self.origin) / vlen(self.velocity), 1);
 133     vector predicted_origin = self.enemy.origin + self.enemy.velocity * time_to_impact;
 134
 135     traceline(self.origin, self.origin + v_forward * 64 - '0 0 32', MOVE_NORMAL, self);
 136     newdir = normalize(predicted_origin - self.origin);
 137
 138     //vector
 139     float height_diff = predicted_origin_z - self.origin_z;
 140
 141     if(vlen(newdir - v_forward) > autocvar_g_vehicle_racer_rocket_locked_maxangle)
 142     {
 143         //bprint("Target lost!\n");
 144         //dprint("OF:", ftos(vlen(newdir - v_forward)), "\n");
 145         self.think = racer_rocket_groundhugger;
 146         return;
 147     }
 148
 149     if(trace_fraction != 1.0 && trace_ent != self.enemy)
 150         newdir_z += 16 * sys_frametime;
 151
 152     self.velocity = normalize(olddir + newdir * autocvar_g_vehicle_racer_rocket_turnrate) * newvel;
 153     self.velocity_z -= 800 * sys_frametime;
 154     self.velocity_z += max(height_diff, autocvar_g_vehicle_racer_rocket_climbspeed) * sys_frametime ;
 155
 156     UpdateCSQCProjectile(self);
 157     return;
 158 }
 159
 160 void racer_rocket_groundhugger()
 161 {SELFPARAM();
 162     vector olddir, newdir;
 163     float oldvel, newvel;
 164
 165     self.nextthink  = time;
 166
 167     if(self.owner.deadflag != DEAD_NO || self.cnt < time)
 168     {
 169         self.use();
 170         return;
 171     }
 172
 173     if(!self.realowner.vehicle)
 174     {
 175         UpdateCSQCProjectile(self);
 176         return;
 177     }
 178
 179     olddir = normalize(self.velocity);
 180     oldvel = vlen(self.velocity);
 181     newvel = oldvel + self.lip;
 182
 183     tracebox(self.origin, self.mins, self.maxs, self.origin + olddir * 64, MOVE_WORLDONLY,self);
 184     if(trace_fraction <= 0.5)
 185     {
 186         // Hitting somethign soon, just speed ahead
 187         self.velocity = olddir * newvel;
 188         UpdateCSQCProjectile(self);
 189         return;
 190     }
 191
 192     traceline(trace_endpos, trace_endpos - '0 0 64', MOVE_NORMAL, self);
 193     if(trace_fraction != 1.0)
 194     {
 195         newdir = normalize(trace_endpos + '0 0 64' - self.origin) * autocvar_g_vehicle_racer_rocket_turnrate;
 196         self.velocity = normalize(olddir + newdir) * newvel;
 197     }
 198     else
 199     {
 200         self.velocity = olddir * newvel;
 201         self.velocity_z -= 1600 * sys_frametime; // 2x grav looks better for this one
 202     }
 203
 204     int cont = pointcontents(self.origin - '0 0 32');
 205     if(cont == CONTENT_WATER || cont == CONTENT_LAVA || cont == CONTENT_SLIME)
 206         self.velocity_z += 200;
 207
 208     UpdateCSQCProjectile(self);
 209     return;
 210 }
 211
 212 #endif
 213
 214 #endif