qcsrc/server/weapons/tracing.qc

   1 // this function calculates w_shotorg and w_shotdir based on the weapon model
   2 // offset, trueaim and antilag, and won't put w_shotorg inside a wall.
   3 // make sure you call makevectors first (FIXME?)
   4 void W_SetupShot_Dir_ProjectileSize_Range(entity ent, vector s_forward, vector mi, vector ma, float antilag, float recoil, string snd, float chan, float maxdamage, float range)
   5 {
   6         float nudge = 1; // added to traceline target and subtracted from result
   7         float oldsolid;
   8         vector vecs, dv;
   9         oldsolid = ent.dphitcontentsmask;
  10         if(ent.weapon == WEP_RIFLE)
  11                 ent.dphitcontentsmask = DPCONTENTS_BODY | DPCONTENTS_CORPSE;
  12         else
  13                 ent.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE;
  14         if(antilag)
  15                 WarpZone_traceline_antilag(world, ent.origin + ent.view_ofs, ent.origin + ent.view_ofs + s_forward * range, MOVE_NORMAL, ent, ANTILAG_LATENCY(ent));
  16                 // passing world, because we do NOT want it to touch dphitcontentsmask
  17         else
  18                 WarpZone_TraceLine(ent.origin + ent.view_ofs, ent.origin + ent.view_ofs + s_forward * range, MOVE_NOMONSTERS, ent);
  19         ent.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE;
  20
  21         vector vf, vr, vu;
  22         vf = v_forward;
  23         vr = v_right;
  24         vu = v_up;
  25         w_shotend = WarpZone_UnTransformOrigin(WarpZone_trace_transform, trace_endpos); // warpzone support
  26         v_forward = vf;
  27         v_right = vr;
  28         v_up = vu;
  29
  30         // un-adjust trueaim if shotend is too close
  31         if(vlen(w_shotend - (ent.origin + ent.view_ofs)) < autocvar_g_trueaim_minrange)
  32                 w_shotend = ent.origin + ent.view_ofs + s_forward * autocvar_g_trueaim_minrange;
  33
  34         // track max damage
  35         if(accuracy_canbegooddamage(ent))
  36                 accuracy_add(ent, ent.weapon, maxdamage, 0);
  37
  38         W_HitPlotAnalysis(ent, v_forward, v_right, v_up);
  39
  40         if(ent.weaponentity.movedir_x > 0)
  41                 vecs = ent.weaponentity.movedir;
  42         else
  43                 vecs = '0 0 0';
  44
  45         dv = v_right * -vecs_y + v_up * vecs_z;
  46         w_shotorg = ent.origin + ent.view_ofs + dv;
  47
  48         // now move the shotorg forward as much as requested if possible
  49         if(antilag)
  50         {
  51                 if(ent.antilag_debug)
  52                         tracebox_antilag(ent, w_shotorg, mi, ma, w_shotorg + v_forward * (vecs_x + nudge), MOVE_NORMAL, ent, ent.antilag_debug);
  53                 else
  54                         tracebox_antilag(ent, w_shotorg, mi, ma, w_shotorg + v_forward * (vecs_x + nudge), MOVE_NORMAL, ent, ANTILAG_LATENCY(ent));
  55         }
  56         else
  57                 tracebox(w_shotorg, mi, ma, w_shotorg + v_forward * (vecs_x + nudge), MOVE_NORMAL, ent);
  58         w_shotorg = trace_endpos - v_forward * nudge;
  59         // calculate the shotdir from the chosen shotorg
  60         w_shotdir = normalize(w_shotend - w_shotorg);
  61
  62         if (antilag)
  63         if (!ent.cvar_cl_noantilag)
  64         {
  65                 if (autocvar_g_antilag == 1) // switch to "ghost" if not hitting original
  66                 {
  67                         traceline(w_shotorg, w_shotorg + w_shotdir * range, MOVE_NORMAL, ent);
  68                         if (!trace_ent.takedamage)
  69                         {
  70                                 traceline_antilag_force (ent, w_shotorg, w_shotorg + w_shotdir * range, MOVE_NORMAL, ent, ANTILAG_LATENCY(ent));
  71                                 if (trace_ent.takedamage && IS_PLAYER(trace_ent))
  72                                 {
  73                                         entity e;
  74                                         e = trace_ent;
  75                                         traceline(w_shotorg, e.origin, MOVE_NORMAL, ent);
  76                                         if(trace_ent == e)
  77                                                 w_shotdir = normalize(trace_ent.origin - w_shotorg);
  78                                 }
  79                         }
  80                 }
  81                 else if(autocvar_g_antilag == 3) // client side hitscan
  82                 {
  83                         // this part MUST use prydon cursor
  84                         if (ent.cursor_trace_ent)                 // client was aiming at someone
  85                         if (ent.cursor_trace_ent != ent)         // just to make sure
  86                         if (ent.cursor_trace_ent.takedamage)      // and that person is killable
  87                         if (IS_PLAYER(ent.cursor_trace_ent)) // and actually a player
  88                         {
  89                                 // verify that the shot would miss without antilag
  90                                 // (avoids an issue where guns would always shoot at their origin)
  91                                 traceline(w_shotorg, w_shotorg + w_shotdir * range, MOVE_NORMAL, ent);
  92                                 if (!trace_ent.takedamage)
  93                                 {
  94                                         // verify that the shot would hit if altered
  95                                         traceline(w_shotorg, ent.cursor_trace_ent.origin, MOVE_NORMAL, ent);
  96                                         if (trace_ent == ent.cursor_trace_ent)
  97                                                 w_shotdir = normalize(ent.cursor_trace_ent.origin - w_shotorg);
  98                                         else
  99                                                 print("antilag fail\n");
 100                                 }
 101                         }
 102                 }
 103         }
 104
 105         ent.dphitcontentsmask = oldsolid; // restore solid type (generally SOLID_SLIDEBOX)
 106
 107         if (!g_norecoil)
 108                 ent.punchangle_x = recoil * -1;
 109
 110         if (snd != "")
 111         {
 112                 sound (ent, chan, snd, VOL_BASE, ATTN_NORM);
 113                 W_PlayStrengthSound(ent);
 114         }
 115
 116         // nudge w_shotend so a trace to w_shotend hits
 117         w_shotend = w_shotend + normalize(w_shotend - w_shotorg) * nudge;
 118 }
 119
 120 vector W_CalculateProjectileVelocity(vector pvelocity, vector mvelocity, float forceAbsolute)
 121 {
 122         vector mdirection;
 123         float mspeed;
 124         vector outvelocity;
 125
 126         mvelocity = mvelocity * g_weaponspeedfactor;
 127
 128         mdirection = normalize(mvelocity);
 129         mspeed = vlen(mvelocity);
 130
 131         outvelocity = get_shotvelocity(pvelocity, mdirection, mspeed, (forceAbsolute ? 0 : autocvar_g_projectiles_newton_style), autocvar_g_projectiles_newton_style_2_minfactor, autocvar_g_projectiles_newton_style_2_maxfactor);
 132
 133         return outvelocity;
 134 }
 135
 136 #if 0
 137 float mspercallsum;
 138 float mspercallsstyle;
 139 float mspercallcount;
 140 #endif
 141 void W_SetupProjectileVelocityEx(entity missile, vector dir, vector upDir, float pSpeed, float pUpSpeed, float pZSpeed, float spread, float forceAbsolute)
 142 {
 143         if(missile.owner == world)
 144                 error("Unowned missile");
 145
 146         dir = dir + upDir * (pUpSpeed / pSpeed);
 147         dir_z += pZSpeed / pSpeed;
 148         pSpeed *= vlen(dir);
 149         dir = normalize(dir);
 150
 151 #if 0
 152         if(autocvar_g_projectiles_spread_style != mspercallsstyle)
 153         {
 154                 mspercallsum = mspercallcount = 0;
 155                 mspercallsstyle = autocvar_g_projectiles_spread_style;
 156         }
 157         mspercallsum -= gettime(GETTIME_HIRES);
 158 #endif
 159         dir = W_CalculateSpread(dir, spread, g_weaponspreadfactor, autocvar_g_projectiles_spread_style);
 160 #if 0
 161         mspercallsum += gettime(GETTIME_HIRES);
 162         mspercallcount += 1;
 163         print("avg: ", ftos(mspercallcount / mspercallsum), " per sec\n");
 164 #endif
 165
 166         missile.velocity = W_CalculateProjectileVelocity(missile.owner.velocity, pSpeed * dir, forceAbsolute);
 167 }
 168
 169 void W_SetupProjectileVelocity(entity missile, float pSpeed, float spread) // WEAPONTODO
 170 {
 171         W_SetupProjectileVelocityEx(missile, w_shotdir, v_up, pSpeed, 0, 0, spread, FALSE);
 172 }
 173
 174
 175 // ====================
 176 //  Ballistics Tracing
 177 // ====================
 178
 179 void FireRailgunBullet (vector start, vector end, float bdamage, float bforce, float mindist, float maxdist, float halflifedist, float forcehalflifedist, float deathtype)
 180 {
 181         vector hitloc, force, endpoint, dir;
 182         entity ent, endent;
 183         float endq3surfaceflags;
 184         float totaldmg;
 185         entity o;
 186
 187         float length;
 188         vector beampos;
 189         string snd;
 190         entity pseudoprojectile;
 191         float f, ffs;
 192
 193         pseudoprojectile = world;
 194
 195         railgun_start = start;
 196         railgun_end = end;
 197
 198         dir = normalize(end - start);
 199         length = vlen(end - start);
 200         force = dir * bforce;
 201
 202         // go a little bit into the wall because we need to hit this wall later
 203         end = end + dir;
 204
 205         totaldmg = 0;
 206
 207         // trace multiple times until we hit a wall, each obstacle will be made
 208         // non-solid so we can hit the next, while doing this we spawn effects and
 209         // note down which entities were hit so we can damage them later
 210         o = self;
 211         while (1)
 212         {
 213                 if(self.antilag_debug)
 214                         WarpZone_traceline_antilag (self, start, end, FALSE, o, self.antilag_debug);
 215                 else
 216                         WarpZone_traceline_antilag (self, start, end, FALSE, o, ANTILAG_LATENCY(self));
 217                 if(o && WarpZone_trace_firstzone)
 218                 {
 219                         o = world;
 220                         continue;
 221                 }
 222
 223                 if(trace_ent.solid == SOLID_BSP || trace_ent.solid == SOLID_SLIDEBOX)
 224                         Damage_DamageInfo(trace_endpos, bdamage, 0, 0, force, deathtype, trace_ent.species, self);
 225
 226                 // if it is world we can't hurt it so stop now
 227                 if (trace_ent == world || trace_fraction == 1)
 228                         break;
 229
 230                 // make the entity non-solid so we can hit the next one
 231                 trace_ent.railgunhit = TRUE;
 232                 trace_ent.railgunhitloc = end;
 233                 trace_ent.railgunhitsolidbackup = trace_ent.solid;
 234                 trace_ent.railgundistance = vlen(WarpZone_UnTransformOrigin(WarpZone_trace_transform, trace_endpos) - start);
 235                 trace_ent.railgunforce = WarpZone_TransformVelocity(WarpZone_trace_transform, force);
 236
 237                 // stop if this is a wall
 238                 if (trace_ent.solid == SOLID_BSP)
 239                         break;
 240
 241                 // make the entity non-solid
 242                 trace_ent.solid = SOLID_NOT;
 243         }
 244
 245         endpoint = trace_endpos;
 246         endent = trace_ent;
 247         endq3surfaceflags = trace_dphitq3surfaceflags;
 248
 249         // find all the entities the railgun hit and restore their solid state
 250         ent = findfloat(world, railgunhit, TRUE);
 251         while (ent)
 252         {
 253                 // restore their solid type
 254                 ent.solid = ent.railgunhitsolidbackup;
 255                 ent = findfloat(ent, railgunhit, TRUE);
 256         }
 257
 258         // spawn a temporary explosion entity for RadiusDamage calls
 259         //explosion = spawn();
 260
 261         // Find all non-hit players the beam passed close by
 262         if(deathtype == WEP_MINSTANEX || deathtype == WEP_NEX)
 263         {
 264                 FOR_EACH_REALCLIENT(msg_entity) if(msg_entity != self) if(!msg_entity.railgunhit) if not(IS_SPEC(msg_entity) && msg_entity.enemy == self) // we use realclient, so spectators can hear the whoosh too
 265                 {
 266                         // nearest point on the beam
 267                         beampos = start + dir * bound(0, (msg_entity.origin - start) * dir, length);
 268
 269                         f = bound(0, 1 - vlen(beampos - msg_entity.origin) / 512, 1);
 270                         if(f <= 0)
 271                                 continue;
 272
 273                         snd = strcat("weapons/nexwhoosh", ftos(floor(random() * 3) + 1), ".wav");
 274
 275                         if(!pseudoprojectile)
 276                                 pseudoprojectile = spawn(); // we need this so the sound uses the "entchannel4" volume
 277                         soundtoat(MSG_ONE, pseudoprojectile, beampos, CH_SHOTS, snd, VOL_BASE * f, ATTN_NONE);
 278                 }
 279
 280                 if(pseudoprojectile)
 281                         remove(pseudoprojectile);
 282         }
 283
 284         // find all the entities the railgun hit and hurt them
 285         ent = findfloat(world, railgunhit, TRUE);
 286         while (ent)
 287         {
 288                 // get the details we need to call the damage function
 289                 hitloc = ent.railgunhitloc;
 290
 291                 f = ExponentialFalloff(mindist, maxdist, halflifedist, ent.railgundistance);
 292                 ffs = ExponentialFalloff(mindist, maxdist, forcehalflifedist, ent.railgundistance);
 293
 294                 if(accuracy_isgooddamage(self.realowner, ent))
 295                         totaldmg += bdamage * f;
 296
 297                 // apply the damage
 298                 if (ent.takedamage)
 299                         Damage (ent, self, self, bdamage * f, deathtype, hitloc, ent.railgunforce * ffs);
 300
 301                 // create a small explosion to throw gibs around (if applicable)
 302                 //setorigin (explosion, hitloc);
 303                 //RadiusDamage (explosion, self, 10, 0, 50, world, world, 300, deathtype);
 304
 305                 ent.railgunhitloc = '0 0 0';
 306                 ent.railgunhitsolidbackup = SOLID_NOT;
 307                 ent.railgunhit = FALSE;
 308                 ent.railgundistance = 0;
 309
 310                 // advance to the next entity
 311                 ent = findfloat(ent, railgunhit, TRUE);
 312         }
 313
 314         // calculate hits and fired shots for hitscan
 315         accuracy_add(self, self.weapon, 0, min(bdamage, totaldmg));
 316
 317         trace_endpos = endpoint;
 318         trace_ent = endent;
 319         trace_dphitq3surfaceflags = endq3surfaceflags;
 320 }
 321
 322 void W_BallisticBullet_Hit (void)
 323 {
 324         float f, q, g;
 325
 326         f = pow(bound(0, vlen(self.velocity) / vlen(self.oldvelocity), 1), 2); // energy multiplier
 327         q = 1 + self.dmg_edge / self.dmg;
 328
 329         if(other.solid == SOLID_BSP || other.solid == SOLID_SLIDEBOX)
 330                 Damage_DamageInfo(self.origin, self.dmg * f, 0, 0, max(1, self.dmg_force) * normalize(self.velocity) * f, self.projectiledeathtype, other.species, self);
 331
 332         if(other && other != self.enemy)
 333         {
 334                 endzcurveparticles();
 335
 336                 yoda = 0;
 337                 railgun_start = self.origin - 2 * frametime * self.velocity;
 338                 railgun_end = self.origin + 2 * frametime * self.velocity;
 339                 g = accuracy_isgooddamage(self.realowner, other);
 340                 Damage(other, self, self.realowner, self.dmg * f, self.projectiledeathtype, self.origin, self.dmg_force * normalize(self.velocity) * f);
 341
 342                 /*if(yoda && (time > (self.last_yoda + 5)))
 343                 {
 344                         Send_Notification(NOTIF_ONE, self.realowner, MSG_ANNCE, ANNCE_ACHIEVEMENT_YODA);
 345                         self.last_yoda = time;
 346                 }*/
 347
 348                 // calculate hits for ballistic weapons
 349                 if(g)
 350                 {
 351                         // do not exceed 100%
 352                         q = min(self.dmg * q, self.dmg_total + f * self.dmg) - self.dmg_total;
 353                         self.dmg_total += f * self.dmg;
 354                         accuracy_add(self.realowner, self.realowner.weapon, 0, q);
 355                 }
 356         }
 357
 358         self.enemy = other; // don't hit the same player twice with the same bullet
 359 }
 360
 361 void W_BallisticBullet_LeaveSolid_think()
 362 {
 363         setorigin(self, self.W_BallisticBullet_LeaveSolid_origin);
 364         self.velocity = self.W_BallisticBullet_LeaveSolid_velocity;
 365
 366         self.think = self.W_BallisticBullet_LeaveSolid_think_save;
 367         self.nextthink = max(time, self.W_BallisticBullet_LeaveSolid_nextthink_save);
 368         self.W_BallisticBullet_LeaveSolid_think_save = func_null;
 369
 370         self.flags &~= FL_ONGROUND;
 371
 372         if(self.enemy.solid == SOLID_BSP)
 373         {
 374                 float f;
 375                 f = pow(bound(0, vlen(self.velocity) / vlen(self.oldvelocity), 1), 2); // energy multiplier
 376                 Damage_DamageInfo(self.origin, 0, 0, 0, max(1, self.dmg_force) * normalize(self.velocity) * -f, self.projectiledeathtype, 0, self);
 377         }
 378
 379         UpdateCSQCProjectile(self);
 380 }
 381
 382 float W_BallisticBullet_LeaveSolid(float eff)
 383 {
 384         // move the entity along its velocity until it's out of solid, then let it resume
 385         vector vel = self.velocity;
 386         float dt, dst, velfactor, v0, vs;
 387         float maxdist;
 388         float E0_m, Es_m;
 389         float constant = self.dmg_radius * (other.ballistics_density ? other.ballistics_density : 1);
 390
 391         // outside the world? forget it
 392         if(self.origin_x > world.maxs_x || self.origin_y > world.maxs_y || self.origin_z > world.maxs_z || self.origin_x < world.mins_x || self.origin_y < world.mins_y || self.origin_z < world.mins_z)
 393                 return 0;
 394
 395         // special case for zero density and zero bullet constant:
 396
 397         if(self.dmg_radius == 0)
 398         {
 399                 if(other.ballistics_density < 0)
 400                         constant = 0; // infinite travel distance
 401                 else
 402                         return 0; // no penetration
 403         }
 404         else
 405         {
 406                 if(other.ballistics_density < 0)
 407                         constant = 0; // infinite travel distance
 408                 else if(other.ballistics_density == 0)
 409                         constant = self.dmg_radius;
 410                 else
 411                         constant = self.dmg_radius * other.ballistics_density;
 412         }
 413
 414         // E(s) = E0 - constant * s, constant = area of bullet circle * material constant / mass
 415         v0 = vlen(vel);
 416
 417         E0_m = 0.5 * v0 * v0;
 418
 419         if(constant)
 420         {
 421                 maxdist = E0_m / constant;
 422                 // maxdist = 0.5 * v0 * v0 / constant
 423                 // dprint("max dist = ", ftos(maxdist), "\n");
 424
 425                 if(maxdist <= autocvar_g_ballistics_mindistance)
 426                         return 0;
 427         }
 428         else
 429         {
 430                 maxdist = vlen(other.maxs - other.mins) + 1; // any distance, as long as we leave the entity
 431         }
 432
 433         traceline_inverted (self.origin, self.origin + normalize(vel) * maxdist, MOVE_NORMAL, self, TRUE);
 434         if(trace_fraction == 1) // 1: we never got out of solid
 435                 return 0;
 436
 437         self.W_BallisticBullet_LeaveSolid_origin = trace_endpos;
 438
 439         dst = max(autocvar_g_ballistics_mindistance, vlen(trace_endpos - self.origin));
 440         // E(s) = E0 - constant * s, constant = area of bullet circle * material constant / mass
 441         Es_m = E0_m - constant * dst;
 442         if(Es_m <= 0)
 443         {
 444                 // roundoff errors got us
 445                 return 0;
 446         }
 447         vs = sqrt(2 * Es_m);
 448         velfactor = vs / v0;
 449
 450         dt = dst / (0.5 * (v0 + vs));
 451         // this is not correct, but the differential equations have no analytic
 452         // solution - and these times are very small anyway
 453         //print("dt = ", ftos(dt), "\n");
 454
 455         self.W_BallisticBullet_LeaveSolid_think_save = self.think;
 456         self.W_BallisticBullet_LeaveSolid_nextthink_save = self.nextthink;
 457         self.think = W_BallisticBullet_LeaveSolid_think;
 458         self.nextthink = time + dt;
 459
 460         vel = vel * velfactor;
 461
 462         self.velocity = '0 0 0';
 463         self.flags |= FL_ONGROUND; // prevent moving
 464         self.W_BallisticBullet_LeaveSolid_velocity = vel;
 465
 466         if(eff >= 0)
 467                 if(vlen(trace_endpos - self.origin) > 4)
 468                 {
 469                         endzcurveparticles();
 470                         trailparticles(self, eff, self.origin, trace_endpos);
 471                 }
 472
 473         return 1;
 474 }
 475
 476 void W_BallisticBullet_Touch (void)
 477 {
 478         //float density;
 479
 480         if(self.think == W_BallisticBullet_LeaveSolid_think) // skip this!
 481                 return;
 482
 483         PROJECTILE_TOUCH;
 484         W_BallisticBullet_Hit ();
 485
 486         if(self.dmg_radius < 0) // these NEVER penetrate solid
 487         {
 488                 remove(self);
 489                 return;
 490         }
 491
 492         // if we hit "weapclip", bail out
 493         //
 494         // rationale of this check:
 495         //
 496         // any shader that is solid, nodraw AND trans is meant to clip weapon
 497         // shots and players, but has no other effect!
 498         //
 499         // if it is not trans, it is caulk and should not have this side effect
 500         //
 501         // matching shaders:
 502         //   common/weapclip (intended)
 503         //   common/noimpact (is supposed to eat projectiles, but is erased farther above)
 504         if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NODRAW)
 505         if not(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NONSOLID)
 506         if not(trace_dphitcontents & DPCONTENTS_OPAQUE)
 507         {
 508                 remove(self);
 509                 return;
 510         }
 511
 512         // go through solid!
 513         if(!W_BallisticBullet_LeaveSolid(-1))
 514         {
 515                 remove(self);
 516                 return;
 517         }
 518
 519         self.projectiledeathtype |= HITTYPE_BOUNCE;
 520 }
 521
 522 void endFireBallisticBullet() // WEAPONTODO
 523 {
 524         endzcurveparticles();
 525 }
 526
 527 void fireBallisticBullet_trace_callback(vector start, vector hit, vector end)
 528 {
 529         if(vlen(trace_endpos - fireBallisticBullet_trace_callback_ent.origin) > 16)
 530                 zcurveparticles_from_tracetoss(fireBallisticBullet_trace_callback_eff, fireBallisticBullet_trace_callback_ent.origin, trace_endpos, fireBallisticBullet_trace_callback_ent.velocity);
 531         WarpZone_trace_forent = world;
 532         self.owner = world;
 533 }
 534
 535 void fireBallisticBullet(vector start, vector dir, float spread, float pSpeed, float lifetime, float damage, float force, float dtype, float tracereffects, float gravityfactor, float bulletconstant)
 536 {
 537         float lag, dt, savetime; //, density;
 538         entity pl, oldself;
 539         float antilagging;
 540
 541         antilagging = (autocvar_g_antilag_bullets && (pSpeed >= autocvar_g_antilag_bullets));
 542
 543         entity proj;
 544         proj = spawn();
 545         proj.classname = "bullet";
 546         proj.owner = proj.realowner = self;
 547         PROJECTILE_MAKETRIGGER(proj);
 548         if(gravityfactor > 0)
 549         {
 550                 proj.movetype = MOVETYPE_TOSS;
 551                 proj.gravity = gravityfactor;
 552         }
 553         else
 554                 proj.movetype = MOVETYPE_FLY;
 555         proj.think = SUB_Remove;
 556         proj.nextthink = time + lifetime; // min(pLifetime, vlen(world.maxs - world.mins) / pSpeed);
 557         W_SetupProjectileVelocityEx(proj, dir, v_up, pSpeed, 0, 0, spread, antilagging);
 558         proj.angles = vectoangles(proj.velocity);
 559         if(bulletconstant > 0)
 560                 proj.dmg_radius = autocvar_g_ballistics_materialconstant / bulletconstant;
 561         else if(bulletconstant == 0)
 562                 proj.dmg_radius = 0;
 563         else
 564                 proj.dmg_radius = -1;
 565         // so: bulletconstant = bullet mass / area of bullet circle
 566         setorigin(proj, start);
 567         proj.flags = FL_PROJECTILE;
 568
 569         proj.touch = W_BallisticBullet_Touch;
 570         proj.dmg = damage;
 571         proj.dmg_force = force;
 572         proj.projectiledeathtype = dtype;
 573
 574         proj.oldvelocity = proj.velocity;
 575
 576         other = proj; MUTATOR_CALLHOOK(EditProjectile);
 577
 578         if(antilagging)
 579         {
 580                 float eff;
 581
 582                 if(tracereffects & EF_RED)
 583                         eff = particleeffectnum("tr_rifle");
 584                 else if(tracereffects & EF_BLUE)
 585                         eff = particleeffectnum("tr_rifle_weak");
 586                 else
 587                         eff = particleeffectnum("tr_bullet");
 588
 589                 // NOTE: this may severely throw off weapon balance
 590                 lag = ANTILAG_LATENCY(self);
 591                 if(lag < 0.001)
 592                         lag = 0;
 593                 if not(IS_REAL_CLIENT(self))
 594                         lag = 0;
 595                 if(autocvar_g_antilag == 0 || self.cvar_cl_noantilag)
 596                         lag = 0; // only do hitscan, but no antilag
 597
 598                 if(lag)
 599                         FOR_EACH_PLAYER(pl)
 600                                 if(pl != self)
 601                                         antilag_takeback(pl, time - lag);
 602
 603                 oldself = self;
 604                 self = proj;
 605
 606                 savetime = frametime;
 607                 frametime = 0.05;
 608
 609                 for(;;)
 610                 {
 611                         // DP tracetoss is stupid and always traces in 0.05s
 612                         // ticks. This makes it trace in 0.05*0.125s ticks
 613                         // instead.
 614                         vector v0;
 615                         float g0;
 616                         v0 = self.velocity;
 617                         g0 = self.gravity;
 618                         self.velocity = self.velocity * 0.125;
 619                         self.gravity *= 0.125 * 0.125;
 620                         trace_fraction = 0;
 621                         fireBallisticBullet_trace_callback_ent = self;
 622                         fireBallisticBullet_trace_callback_eff = eff;
 623                         WarpZone_TraceToss_ThroughZone(self, self.owner, world, fireBallisticBullet_trace_callback);
 624                         self.velocity = v0;
 625                         self.gravity = g0;
 626
 627                         if(trace_fraction == 1)
 628                                 break;
 629                                 // won't hit anything anytime soon (DP's
 630                                 // tracetoss does 200 tics of, here,
 631                                 // 0.05*0.125s, that is, 1.25 seconds
 632
 633                         other = trace_ent;
 634                         dt = WarpZone_tracetoss_time * 0.125; // this is only approximate!
 635                         setorigin(self, trace_endpos);
 636                         self.velocity = WarpZone_tracetoss_velocity * (1 / 0.125);
 637
 638                         if(!SUB_OwnerCheck())
 639                         {
 640                                 if(SUB_NoImpactCheck())
 641                                         break;
 642
 643                                 // hit the player
 644                                 W_BallisticBullet_Hit();
 645                         }
 646
 647                         if(proj.dmg_radius < 0) // these NEVER penetrate solid
 648                                 break;
 649
 650                         // if we hit "weapclip", bail out
 651                         //
 652                         // rationale of this check:
 653                         //
 654                         // any shader that is solid, nodraw AND trans is meant to clip weapon
 655                         // shots and players, but has no other effect!
 656                         //
 657                         // if it is not trans, it is caulk and should not have this side effect
 658                         //
 659                         // matching shaders:
 660                         //   common/weapclip (intended)
 661                         //   common/noimpact (is supposed to eat projectiles, but is erased farther above)
 662                         if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NODRAW)
 663                         if not(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NONSOLID)
 664                         if not(trace_dphitcontents & DPCONTENTS_OPAQUE)
 665                                 break;
 666
 667                         // go through solid!
 668                         if(!W_BallisticBullet_LeaveSolid((other && (other.solid != SOLID_BSP)) ? eff : -1))
 669                                 break;
 670
 671                         W_BallisticBullet_LeaveSolid_think();
 672
 673                         self.projectiledeathtype |= HITTYPE_BOUNCE;
 674                 }
 675                 frametime = savetime;
 676                 self = oldself;
 677
 678                 if(lag)
 679                         FOR_EACH_PLAYER(pl)
 680                                 if(pl != self)
 681                                         antilag_restore(pl);
 682
 683                 remove(proj);
 684
 685                 return;
 686         }
 687
 688         if(tracereffects & EF_RED)
 689                 CSQCProjectile(proj, TRUE, PROJECTILE_BULLET_GLOWING_TRACER, TRUE);
 690         else if(tracereffects & EF_BLUE)
 691                 CSQCProjectile(proj, TRUE, PROJECTILE_BULLET_GLOWING, TRUE);
 692         else
 693                 CSQCProjectile(proj, TRUE, PROJECTILE_BULLET, TRUE);
 694 }
 695
 696 void fireBullet (vector start, vector dir, float spread, float damage, float force, float dtype, float tracer)
 697 {
 698         vector  end;
 699
 700         dir = normalize(dir + randomvec() * spread);
 701         end = start + dir * MAX_SHOT_DISTANCE;
 702         if(self.antilag_debug)
 703                 traceline_antilag (self, start, end, FALSE, self, self.antilag_debug);
 704         else
 705                 traceline_antilag (self, start, end, FALSE, self, ANTILAG_LATENCY(self));
 706
 707         end = trace_endpos;
 708
 709         if (pointcontents (trace_endpos) != CONTENT_SKY)
 710         {
 711                 if not (trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
 712                         Damage_DamageInfo(trace_endpos, damage, 0, 0, dir * max(1, force), dtype, trace_ent.species, self);
 713
 714                 Damage (trace_ent, self, self, damage, dtype, trace_endpos, dir * force);
 715         }
 716         trace_endpos = end;
 717 }