961335de4006c4a65b61ecbb2615a37735dd17c2
[xonotic/xonotic-data.pk3dir.git] / 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 (!autocvar_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         dir = normalize(end - start);
196         length = vlen(end - start);
197         force = dir * bforce;
198
199         // go a little bit into the wall because we need to hit this wall later
200         end = end + dir;
201
202         totaldmg = 0;
203
204         // trace multiple times until we hit a wall, each obstacle will be made
205         // non-solid so we can hit the next, while doing this we spawn effects and
206         // note down which entities were hit so we can damage them later
207         o = self;
208         while (1)
209         {
210                 if(self.antilag_debug)
211                         WarpZone_traceline_antilag (self, start, end, FALSE, o, self.antilag_debug);
212                 else
213                         WarpZone_traceline_antilag (self, start, end, FALSE, o, ANTILAG_LATENCY(self));
214                 if(o && WarpZone_trace_firstzone)
215                 {
216                         o = world;
217                         continue;
218                 }
219
220                 if(trace_ent.solid == SOLID_BSP || trace_ent.solid == SOLID_SLIDEBOX)
221                         Damage_DamageInfo(trace_endpos, bdamage, 0, 0, force, deathtype, trace_ent.species, self);
222
223                 // if it is world we can't hurt it so stop now
224                 if (trace_ent == world || trace_fraction == 1)
225                         break;
226
227                 // make the entity non-solid so we can hit the next one
228                 trace_ent.railgunhit = TRUE;
229                 trace_ent.railgunhitloc = end;
230                 trace_ent.railgunhitsolidbackup = trace_ent.solid;
231                 trace_ent.railgundistance = vlen(WarpZone_UnTransformOrigin(WarpZone_trace_transform, trace_endpos) - start);
232                 trace_ent.railgunforce = WarpZone_TransformVelocity(WarpZone_trace_transform, force);
233
234                 // stop if this is a wall
235                 if (trace_ent.solid == SOLID_BSP)
236                         break;
237
238                 // make the entity non-solid
239                 trace_ent.solid = SOLID_NOT;
240         }
241
242         endpoint = trace_endpos;
243         endent = trace_ent;
244         endq3surfaceflags = trace_dphitq3surfaceflags;
245
246         // find all the entities the railgun hit and restore their solid state
247         ent = findfloat(world, railgunhit, TRUE);
248         while (ent)
249         {
250                 // restore their solid type
251                 ent.solid = ent.railgunhitsolidbackup;
252                 ent = findfloat(ent, railgunhit, TRUE);
253         }
254
255         // spawn a temporary explosion entity for RadiusDamage calls
256         //explosion = spawn();
257
258         // Find all non-hit players the beam passed close by
259         if(deathtype == WEP_MINSTANEX || deathtype == WEP_NEX)
260         {
261                 FOR_EACH_REALCLIENT(msg_entity)
262                 if(msg_entity != self)
263                 if(!msg_entity.railgunhit)
264                 if(!(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, ATTEN_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 fireBullet_trace_callback(vector start, vector hit, vector end)
323 {
324         if(vlen(hit - start) > 16)
325                 trailparticles(world, fireBullet_trace_callback_eff, start, hit);
326         WarpZone_trace_forent = world;
327         fireBullet_last_hit = world;
328 }
329
330 void fireBullet(vector start, vector dir, float spread, float max_solid_penetration, float damage, float force, float dtype, float tracereffects)
331 {
332         vector  end;
333
334         dir = normalize(dir + randomvec() * spread);
335         end = start + dir * MAX_SHOT_DISTANCE;
336
337         entity pl;
338         fireBullet_last_hit = world;
339         float solid_penetration_left = 1;
340         float total_damage = 0;
341
342         if(tracereffects & EF_RED)
343                 fireBullet_trace_callback_eff = particleeffectnum("tr_rifle");
344         else if(tracereffects & EF_BLUE)
345                 fireBullet_trace_callback_eff = particleeffectnum("tr_rifle_weak");
346         else
347                 fireBullet_trace_callback_eff = particleeffectnum("tr_bullet");
348
349         float lag = ANTILAG_LATENCY(self);
350         if(lag < 0.001)
351                 lag = 0;
352         if (!IS_REAL_CLIENT(self))
353                 lag = 0;
354         if(autocvar_g_antilag == 0 || self.cvar_cl_noantilag)
355                 lag = 0; // only do hitscan, but no antilag
356         if(lag)
357                 FOR_EACH_PLAYER(pl)
358                         if(pl != self)
359                                 antilag_takeback(pl, time - lag);
360
361         WarpZone_trace_forent = self;
362
363         for (;;)
364         {
365                 // TODO also show effect while tracing
366                 WarpZone_TraceBox_ThroughZone(start, '0 0 0', '0 0 0', end, FALSE, WarpZone_trace_forent, world, fireBullet_trace_callback);
367                 dir = WarpZone_TransformVelocity(WarpZone_trace_transform, dir);
368                 end = WarpZone_TransformOrigin(WarpZone_trace_transform, end);
369                 start = trace_endpos;
370                 entity hit = trace_ent;
371
372                 // When hitting sky, stop.
373                 if (pointcontents(start) == CONTENT_SKY)
374                         break;
375
376                 if (trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
377                         break;
378
379                 // if we hit "weapclip", bail out
380                 //
381                 // rationale of this check:
382                 //
383                 // any shader that is solid, nodraw AND trans is meant to clip weapon
384                 // shots and players, but has no other effect!
385                 //
386                 // if it is not trans, it is caulk and should not have this side effect
387                 //
388                 // matching shaders:
389                 //   common/weapclip (intended)
390                 //   common/noimpact (is supposed to eat projectiles, but is erased anyway)
391                 float is_weapclip = 0;
392                 if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NODRAW)
393                 if (!(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NONSOLID))
394                 if (!(trace_dphitcontents & DPCONTENTS_OPAQUE))
395                         is_weapclip = 1;
396
397                 if(!hit || hit.solid == SOLID_BSP || hit.solid == SOLID_SLIDEBOX)
398                         Damage_DamageInfo(start, damage * solid_penetration_left, 0, 0, max(1, force) * dir * solid_penetration_left, dtype, hit.species, self);
399
400                 if (hit && hit != WarpZone_trace_forent && hit != fireBullet_last_hit)  // Avoid self-damage (except after going through a warp); avoid hitting the same entity twice (engine bug).
401                 {
402                         fireBullet_last_hit = hit;
403                         yoda = 0;
404                         float g = accuracy_isgooddamage(self, hit);
405                         Damage(hit, self, self, damage * solid_penetration_left, dtype, start, force * dir * solid_penetration_left);
406                         // calculate hits for ballistic weapons
407                         if(g)
408                         {
409                                 // do not exceed 100%
410                                 float added_damage = min(damage - total_damage, damage * solid_penetration_left);
411                                 total_damage += damage * solid_penetration_left;
412                                 accuracy_add(self, self.weapon, 0, added_damage);
413                         }
414                 }
415
416                 if (is_weapclip)
417                         break;
418
419                 // go through solid!
420                 // outside the world? forget it
421                 if(start_x > world.maxs_x || start_y > world.maxs_y || start_z > world.maxs_z || start_x < world.mins_x || start_y < world.mins_y || start_z < world.mins_z)
422                         break;
423
424                 float maxdist;
425                 if(max_solid_penetration < 0)
426                         break;
427                 else if(hit.ballistics_density < -1)
428                         break; // -2: no solid penetration, ever
429                 else if(hit.ballistics_density < 0)
430                         maxdist = vlen(hit.maxs - hit.mins) + 1; // -1: infinite travel distance
431                 else if(hit.ballistics_density == 0)
432                         maxdist = max_solid_penetration * solid_penetration_left;
433                 else
434                         maxdist = max_solid_penetration * solid_penetration_left * hit.ballistics_density;
435
436                 if(maxdist <= autocvar_g_ballistics_mindistance)
437                         break;
438
439                 // move the entity along its velocity until it's out of solid, then let it resume
440                 // The previously hit entity is ignored here!
441                 traceline_inverted (start, start + dir * maxdist, MOVE_NORMAL, WarpZone_trace_forent, TRUE, hit);
442                 if(trace_fraction == 1) // 1: we never got out of solid
443                         break;
444
445                 float dist_taken = max(autocvar_g_ballistics_mindistance, vlen(trace_endpos - start));
446                 solid_penetration_left *= (dist_taken / maxdist);
447
448                 // Only show effect when going through a player (invisible otherwise)
449                 if (hit && (hit.solid != SOLID_BSP))
450                         if(vlen(trace_endpos - start) > 4)
451                                 trailparticles(self, fireBullet_trace_callback_eff, start, trace_endpos);
452
453                 start = trace_endpos;
454
455                 if(hit.solid == SOLID_BSP)
456                         Damage_DamageInfo(start, 0, 0, 0, max(1, force) * normalize(dir) * -solid_penetration_left, dtype, 0, self);
457         }
458
459         if(lag)
460                 FOR_EACH_PLAYER(pl)
461                         if(pl != self)
462                                 antilag_restore(pl);
463 }