Give W_SetupShot a deathtype parameter, fixes some ugly hacks
[xonotic/xonotic-data.pk3dir.git] / qcsrc / common / weapons / weapon / tuba.qc
1 #include "tuba.qh"
2
3 #ifdef SVQC
4
5 .entity tuba_note;
6 .float tuba_smoketime;
7
8 #define MAX_TUBANOTES 32
9 .float tuba_lastnotes_last;
10 .float tuba_lastnotes_cnt; // over
11 .vector tuba_lastnotes[MAX_TUBANOTES];
12
13 bool W_Tuba_HasPlayed(entity pl, .entity weaponentity, string melody, int instrument, bool ignorepitch, float mintempo, float maxtempo)
14 {
15         float i, j, mmin, mmax, nolength;
16         float n = tokenize_console(melody);
17         if(n > pl.(weaponentity).tuba_lastnotes_cnt)
18                 return false;
19         float pitchshift = 0;
20
21         if(instrument >= 0)
22                 if(pl.(weaponentity).tuba_instrument != instrument)
23                         return false;
24
25         // verify notes...
26         nolength = false;
27         for(i = 0; i < n; ++i)
28         {
29                 vector v = pl.(weaponentity).(tuba_lastnotes[(pl.(weaponentity).tuba_lastnotes_last - i + MAX_TUBANOTES) % MAX_TUBANOTES]);
30                 float ai = stof(argv(n - i - 1));
31                 float np = floor(ai);
32                 if(ai == np)
33                         nolength = true;
34                 // n counts the last played notes BACKWARDS
35                 // _x is start
36                 // _y is end
37                 // _z is note pitch
38                 if(ignorepitch && i == 0)
39                 {
40                         pitchshift = np - v.z;
41                 }
42                 else
43                 {
44                         if(v.z + pitchshift != np)
45                                 return false;
46                 }
47         }
48
49         // now we know the right NOTES were played
50         if(!nolength)
51         {
52                 // verify rhythm...
53                 float ti = 0;
54                 if(maxtempo > 0)
55                         mmin = 240 / maxtempo; // 60 = "0.25 means 1 sec", at 120 0.5 means 1 sec, at 240 1 means 1 sec
56                 else
57                         mmin = 0;
58                 if(mintempo > 0)
59                         mmax = 240 / mintempo; // 60 = "0.25 means 1 sec", at 120 0.5 means 1 sec, at 240 1 means 1 sec
60                 else
61                         mmax = 240; // you won't try THAT hard... (tempo 1)
62                 //printf("initial tempo rules: %f %f\n", mmin, mmax);
63
64                 for(i = 0; i < n; ++i)
65                 {
66                         vector vi = pl.(weaponentity).(tuba_lastnotes[(pl.(weaponentity).tuba_lastnotes_last - i + MAX_TUBANOTES) % MAX_TUBANOTES]);
67                         float ai = stof(argv(n - i - 1));
68                         ti -= 1 / (ai - floor(ai));
69                         float tj = ti;
70                         for(j = i+1; j < n; ++j)
71                         {
72                                 vector vj = pl.(weaponentity).(tuba_lastnotes[(pl.(weaponentity).tuba_lastnotes_last - j + MAX_TUBANOTES) % MAX_TUBANOTES]);
73                                 float aj = stof(argv(n - j - 1));
74                                 tj -= (aj - floor(aj));
75
76                                 // note i should be at m*ti+b
77                                 // note j should be at m*tj+b
78                                 // so:
79                                 // we have a LINE l, so that
80                                 // vi_x <= l(ti) <= vi_y
81                                 // vj_x <= l(tj) <= vj_y
82                                 // what is m?
83
84                                 // vi_x <= vi_y <= vj_x <= vj_y
85                                 // ti <= tj
86                                 //printf("first note: %f to %f, should be %f\n", vi_x, vi_y, ti);
87                                 //printf("second note: %f to %f, should be %f\n", vj_x, vj_y, tj);
88                                 //printf("m1 = %f\n", (vi_x - vj_y) / (ti - tj));
89                                 //printf("m2 = %f\n", (vi_y - vj_x) / (ti - tj));
90                                 mmin = max(mmin, (vi.x - vj.y) / (ti - tj)); // lower bound
91                                 mmax = min(mmax, (vi.y - vj.x) / (ti - tj)); // upper bound
92                         }
93                 }
94
95                 if(mmin > mmax) // rhythm fail
96                         return false;
97         }
98
99         pl.(weaponentity).tuba_lastnotes_cnt = 0;
100
101         return true;
102 }
103
104 void W_Tuba_NoteOff(entity this)
105 {
106         entity actor = this.owner;
107         // we have a note:
108         //   on: this.spawnshieldtime
109         //   off: time
110         //   note: this.cnt
111         .entity weaponentity = this.weaponentity_fld;
112         if (actor.(weaponentity).tuba_note == this)
113         {
114                 actor.(weaponentity).tuba_lastnotes_last = (actor.(weaponentity).tuba_lastnotes_last + 1) % MAX_TUBANOTES;
115                 actor.(weaponentity).(tuba_lastnotes[actor.(weaponentity).tuba_lastnotes_last]) = vec3(this.spawnshieldtime, time, this.cnt);
116                 actor.(weaponentity).tuba_note = NULL;
117                 actor.(weaponentity).tuba_lastnotes_cnt = bound(0, actor.(weaponentity).tuba_lastnotes_cnt + 1, MAX_TUBANOTES);
118
119                 string s = trigger_magicear_processmessage_forallears(actor, 0, NULL, string_null);
120                 if (s != "")
121                 {
122                         // simulate a server message
123                         switch (this.tuba_instrument)
124                         {
125                                 default:
126                                 case 0: // Tuba
127                                         bprint(strcat("\{1}\{13}* ^3", actor.netname, "^3 played on the @!#%'n Tuba: ^7", s, "\n"));
128                                         break;
129                                 case 1:
130                                         bprint(strcat("\{1}\{13}* ^3", actor.netname, "^3 played on the @!#%'n Accordeon: ^7", s, "\n"));
131                                         break;
132                                 case 2:
133                                         bprint(strcat("\{1}\{13}* ^3", actor.netname, "^3 played on the @!#%'n Klein Bottle: ^7", s, "\n"));
134                                         break;
135                         }
136                 }
137         }
138         delete(this);
139 }
140
141 int W_Tuba_GetNote(entity pl, int hittype)
142 {
143         float movestate = 5;
144         if (CS(pl).movement.x < 0)              movestate -= 3;
145         else if (CS(pl).movement.x > 0) movestate += 3;
146         if (CS(pl).movement.y < 0)              movestate -= 1;
147         else if (CS(pl).movement.y > 0) movestate += 1;
148
149         int note = 0;
150         switch (movestate)
151         {
152         // layout: originally I wanted
153         //   eb e  e#=f
154         //   B  c  d
155         //   Gb G  G#
156         // but then you only use forward and right key. So to make things more
157         // interesting, I swapped B with e#. Har har har...
158         //   eb e  B
159         // f=e# c  d
160         //   Gb G  G#
161                 case 1: note = -6; break; // Gb
162                 case 2: note = -5; break; // G
163                 case 3: note = -4; break; // G#
164                 case 4: note = +5; break; // e#
165                 default:
166                 case 5: note =  0; break; // c
167                 case 6: note = +2; break; // d
168                 case 7: note = +3; break; // eb
169                 case 8: note = +4; break; // e
170                 case 9: note = -1; break; // B
171         }
172         if(PHYS_INPUT_BUTTON_CROUCH(pl))
173                 note -= 12;
174         if(PHYS_INPUT_BUTTON_JUMP(pl))
175                 note += 12;
176         if(hittype & HITTYPE_SECONDARY)
177                 note += 7;
178
179         // we support two kinds of tubas, those tuned in Eb and those tuned in C
180         // kind of tuba currently is player slot number, or team number if in
181         // teamplay
182         // that way, holes in the range of notes are "plugged"
183         if(teamplay)
184         {
185                 if(pl.team == NUM_TEAM_2 || pl.team == NUM_TEAM_4)
186                         note += 3;
187         }
188         else
189         {
190                 if(pl.clientcolors & 1)
191                         note += 3;
192         }
193
194         // total range of notes:
195         //                       0
196         //                 ***  ** ****
197         //                        ***  ** ****
198         //     ***  ** ****
199         //            ***  ** ****
200         //     ***  ********************* ****
201         //     -18.........................+12
202         //        ***  ********************* ****
203         //     -18............................+15
204         //     with jump: ... +24
205         //     ... +27
206         return note;
207 }
208
209 bool W_Tuba_NoteSendEntity(entity this, entity to, int sf)
210 {
211         msg_entity = to;
212         if (!sound_allowed(MSG_ONE, this.realowner)) return false;
213
214         WriteHeader(MSG_ENTITY, ENT_CLIENT_TUBANOTE);
215         WriteByte(MSG_ENTITY, sf);
216         if (sf & 1)
217         {
218                 WriteChar(MSG_ENTITY, this.cnt);
219                 int f = 0;
220                 f |= 1 * (this.realowner != to);
221                 f |= 2 * this.tuba_instrument;
222                 WriteByte(MSG_ENTITY, f);
223         }
224         if (sf & 2)
225         {
226                 WriteCoord(MSG_ENTITY, this.origin.x);
227                 WriteCoord(MSG_ENTITY, this.origin.y);
228                 WriteCoord(MSG_ENTITY, this.origin.z);
229         }
230         return true;
231 }
232
233 void W_Tuba_NoteThink(entity this)
234 {
235         float dist_mult;
236         float vol0, vol1;
237         vector dir0, dir1;
238         vector v;
239         if(time > this.teleport_time)
240         {
241                 W_Tuba_NoteOff(this);
242                 return;
243         }
244         this.nextthink = time;
245         dist_mult = WEP_CVAR(tuba, attenuation) / autocvar_snd_soundradius;
246         FOREACH_CLIENT(IS_REAL_CLIENT(it) && it != this.realowner, {
247                 v = this.origin - (it.origin + it.view_ofs);
248                 vol0 = max(0, 1 - vlen(v) * dist_mult);
249                 dir0 = normalize(v);
250                 v = this.realowner.origin - (it.origin + it.view_ofs);
251                 vol1 = max(0, 1 - vlen(v) * dist_mult);
252                 dir1 = normalize(v);
253                 if(fabs(vol0 - vol1) > 0.005) // 0.5 percent change in volume
254                 {
255                         setorigin(this, this.realowner.origin);
256                         this.SendFlags |= 2;
257                         break;
258                 }
259                 if(dir0 * dir1 < 0.9994) // 2 degrees change in angle
260                 {
261                         setorigin(this, this.realowner.origin);
262                         this.SendFlags |= 2;
263                         break;
264                 }
265         });
266 }
267
268 void W_Tuba_NoteOn(entity actor, .entity weaponentity, float hittype)
269 {
270         vector o;
271         float n = W_Tuba_GetNote(actor, hittype);
272
273         hittype = 0;
274         if(actor.(weaponentity).tuba_instrument & 1)
275                 hittype |= HITTYPE_SECONDARY;
276         if(actor.(weaponentity).tuba_instrument & 2)
277                 hittype |= HITTYPE_BOUNCE;
278
279         W_SetupShot(actor, weaponentity, false, 2, SND_Null, 0, WEP_CVAR(tuba, damage), hittype | WEP_TUBA.m_id);
280
281         if(actor.(weaponentity).tuba_note)
282         {
283                 if(actor.(weaponentity).tuba_note.cnt != n || actor.(weaponentity).tuba_note.tuba_instrument != actor.(weaponentity).tuba_instrument)
284                 {
285                         W_Tuba_NoteOff(actor.(weaponentity).tuba_note);
286                 }
287         }
288
289         if(!actor.(weaponentity).tuba_note)
290         {
291                 entity note = new(tuba_note);
292                 note.weaponentity_fld = weaponentity;
293                 actor.(weaponentity).tuba_note = note;
294                 note.owner = note.realowner = actor;
295                 note.cnt = n;
296                 note.tuba_instrument = actor.(weaponentity).tuba_instrument;
297                 setthink(note, W_Tuba_NoteThink);
298                 note.nextthink = time;
299                 note.spawnshieldtime = time;
300                 Net_LinkEntity(note, false, 0, W_Tuba_NoteSendEntity);
301         }
302
303         actor.(weaponentity).tuba_note.teleport_time = time + WEP_CVAR(tuba, refire) * 2 * W_WeaponRateFactor(actor); // so it can get prolonged safely
304
305         //sound(actor, c, TUBA_NOTE(n), bound(0, VOL_BASE * cvar("g_balance_tuba_volume"), 1), autocvar_g_balance_tuba_attenuation);
306         RadiusDamage(actor, actor, WEP_CVAR(tuba, damage), WEP_CVAR(tuba, edgedamage), WEP_CVAR(tuba, radius), NULL, NULL, WEP_CVAR(tuba, force), hittype | WEP_TUBA.m_id, weaponentity, NULL);
307
308         o = gettaginfo(actor.exteriorweaponentity, 0);
309         if(time > actor.(weaponentity).tuba_smoketime)
310         {
311                 Send_Effect(EFFECT_SMOKE_RING, o + v_up * 45 + v_right * -6 + v_forward * 8, v_up * 100, 1);
312                 actor.(weaponentity).tuba_smoketime = time + 0.25;
313         }
314 }
315 #endif
316
317 #ifdef SVQC
318 METHOD(Tuba, wr_aim, void(Tuba this, entity actor, .entity weaponentity))
319 {
320         // bots cannot play the Tuba well yet
321         // I think they should start with the recorder first
322         if (vdist((actor.origin - actor.enemy.origin), <, WEP_CVAR(tuba, radius)))
323         {
324                 if (random() > 0.5)
325                         PHYS_INPUT_BUTTON_ATCK(actor) = true;
326                 else
327                         PHYS_INPUT_BUTTON_ATCK2(actor) = true;
328         }
329 }
330
331 METHOD(Tuba, wr_think, void(Tuba this, entity actor, .entity weaponentity, int fire))
332 {
333         if (fire & 1)
334         if (weapon_prepareattack(this, actor, weaponentity, false, WEP_CVAR(tuba, refire)))
335         {
336                 W_Tuba_NoteOn(actor, weaponentity, 0);
337                 weapon_thinkf(actor, weaponentity, WFRAME_IDLE, WEP_CVAR(tuba, animtime), w_ready);
338         }
339         if (fire & 2)
340         if (weapon_prepareattack(this, actor, weaponentity, true, WEP_CVAR(tuba, refire)))
341         {
342                 W_Tuba_NoteOn(actor, weaponentity, HITTYPE_SECONDARY);
343                 weapon_thinkf(actor, weaponentity, WFRAME_IDLE, WEP_CVAR(tuba, animtime), w_ready);
344         }
345         if (actor.(weaponentity).tuba_note)
346         {
347                 if (!(fire & 1) && !(fire & 2))
348                 {
349                         W_Tuba_NoteOff(actor.(weaponentity).tuba_note);
350                 }
351         }
352 }
353
354 METHOD(Tuba, wr_setup, void(Tuba this, entity actor, .entity weaponentity))
355 {
356         actor.(weaponentity).tuba_instrument = 0;
357 }
358
359 METHOD(Tuba, wr_reload, void(Tuba this, entity actor, .entity weaponentity))
360 {
361         // switch to alternate instruments :)
362         if (actor.(weaponentity).state == WS_READY)
363         {
364                 switch (actor.(weaponentity).tuba_instrument)
365                 {
366                         case 0:
367                                 actor.(weaponentity).tuba_instrument = 1;
368                                 actor.(weaponentity).weaponname = "akordeon";
369                                 break;
370                         case 1:
371                                 actor.(weaponentity).tuba_instrument = 2;
372                                 actor.(weaponentity).weaponname = "kleinbottle";
373                                 break;
374                         case 2:
375                                 actor.(weaponentity).tuba_instrument = 0;
376                                 actor.(weaponentity).weaponname = "tuba";
377                                 break;
378                 }
379                 int hittype = 0;
380                 if(actor.(weaponentity).tuba_instrument & 1)
381                         hittype |= HITTYPE_SECONDARY;
382                 if(actor.(weaponentity).tuba_instrument & 2)
383                         hittype |= HITTYPE_BOUNCE;
384                 W_SetupShot(actor, weaponentity, false, 0, SND_Null, 0, 0, hittype | WEP_TUBA.m_id);
385                 Send_Effect(EFFECT_TELEPORT, w_shotorg, '0 0 0', 1);
386                 actor.(weaponentity).state = WS_INUSE;
387                 weapon_thinkf(actor, weaponentity, WFRAME_RELOAD, 0.5, w_ready);
388         }
389 }
390 #endif
391
392 #ifdef SVQC
393
394 // infinite ammo
395 METHOD(Tuba, wr_checkammo1, bool(Tuba this, entity actor, .entity weaponentity)) { return true; }
396 METHOD(Tuba, wr_checkammo2, bool(Tuba this, entity actor, .entity weaponentity)) { return true; }
397
398 METHOD(Tuba, wr_suicidemessage, Notification(Tuba this))
399 {
400         if (w_deathtype & HITTYPE_BOUNCE)
401                 return WEAPON_KLEINBOTTLE_SUICIDE;
402         else if (w_deathtype & HITTYPE_SECONDARY)
403                 return WEAPON_ACCORDEON_SUICIDE;
404         else
405                 return WEAPON_TUBA_SUICIDE;
406 }
407 METHOD(Tuba, wr_killmessage, Notification(Tuba this))
408 {
409         if (w_deathtype & HITTYPE_BOUNCE)
410                 return WEAPON_KLEINBOTTLE_MURDER;
411         else if (w_deathtype & HITTYPE_SECONDARY)
412                 return WEAPON_ACCORDEON_MURDER;
413         else
414                 return WEAPON_TUBA_MURDER;
415 }
416
417 #elif defined(CSQC)
418
419 METHOD(Tuba, wr_viewmodel, string(Tuba this, entity wep))
420 {
421         return (wep.tuba_instrument == 0) ? "tuba" :
422                (wep.tuba_instrument == 1) ? "akordeon" :
423                                             "kleinbottle";
424 }
425
426 #endif
427
428 #ifdef CSQC
429
430 #define TUBA_STARTNOTE(i, n) _Sound_fixpath(W_Sound(strcat("tuba", (i ? ftos(i) : ""), "_loopnote", ftos(n))))
431
432 const int TUBA_MIN = -18;
433 const int TUBA_MAX = 27;
434 const int TUBA_INSTRUMENTS = 3;
435
436 int Tuba_PitchStep;
437
438 void tubasound(entity e, bool restart)
439 {
440         string snd1 = string_null;
441         if (Tuba_PitchStep) {
442                 float vol1 = 1;
443                 float speed1 = 1;
444                 string snd2 = string_null;
445                 float vol2 = 0;
446                 float speed2 = 1;
447
448                 int m = pymod(e.note, Tuba_PitchStep);
449                 if (m) {
450                         if (e.note - m < TUBA_MIN) {
451                                 if (restart) {
452                                         snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note - m + Tuba_PitchStep);
453                                 }
454                                 speed1 = (2.0 ** ((m - Tuba_PitchStep) / 12.0));
455                         } else if (e.note - m + Tuba_PitchStep > TUBA_MAX) {
456                                 if (restart) {
457                                         snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note - m);
458                                 }
459                                 speed1 = (2.0 ** (m / 12.0));
460                         } else {
461                                 if (restart) {
462                                         snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note - m);
463                                 }
464                                 vol1 = cos(M_PI_2 * m / Tuba_PitchStep);
465                                 speed1 = (2.0 ** (m / 12.0));
466                                 if (restart) {
467                                         snd2 = TUBA_STARTNOTE(e.tuba_instrument, e.note - m + Tuba_PitchStep);
468                                 }
469                                 vol2 = sin(M_PI_2 * m / Tuba_PitchStep);
470                                 speed2 = (2.0 ** ((m - Tuba_PitchStep) / 12.0));
471                         }
472                 } else if (restart) {
473                         snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note);
474                 }
475
476                 sound7(e, CH_TUBA_SINGLE, snd1, e.tuba_volume * vol1, e.tuba_attenuate * autocvar_g_balance_tuba_attenuation, 100 * speed1, 0);
477                 if (vol2) {
478                         sound7(e.enemy, CH_TUBA_SINGLE, snd2, e.tuba_volume * vol2, e.tuba_attenuate * autocvar_g_balance_tuba_attenuation, 100 * speed2, 0);
479                 }
480         } else {
481                 if (restart) {
482                         snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note);
483                 }
484                 _sound(e, CH_TUBA_SINGLE, snd1, e.tuba_volume, e.tuba_attenuate * autocvar_g_balance_tuba_attenuation);
485         }
486 }
487
488 void Ent_TubaNote_Think(entity this)
489 {
490         float f = autocvar_g_balance_tuba_fadetime;
491         if (f > 0) {
492                 this.tuba_volume -= frametime * this.tuba_volume_initial / f;
493         } else {
494                 this.tuba_volume = 0;
495         }
496         this.nextthink = time;
497         if (this.tuba_volume <= 0) {
498                 sound(this, CH_TUBA_SINGLE, SND_Null, 0, 0);
499                 if (this.enemy) {
500                         sound(this.enemy, CH_TUBA_SINGLE, SND_Null, 0, 0);
501                         delete(this.enemy);
502                 }
503                 delete(this);
504         } else {
505                 tubasound(this, 0);
506         }
507 }
508
509 void Ent_TubaNote_UpdateSound(entity this)
510 {
511         this.enemy.tuba_volume = bound(0, VOL_BASE * autocvar_g_balance_tuba_volume, 1);
512         this.enemy.tuba_volume_initial = this.enemy.tuba_volume;
513         this.enemy.note = this.note;
514         this.enemy.tuba_instrument = this.tuba_instrument;
515         tubasound(this.enemy, 1);
516 }
517
518 void Ent_TubaNote_StopSound(entity this)
519 {
520         this.enemy.nextthink = time;
521         this.enemy = NULL;
522 }
523
524 NET_HANDLE(ENT_CLIENT_TUBANOTE, bool isNew)
525 {
526         bool upd = false;
527         int f = ReadByte();
528         if (f & 1) {
529                 int n = ReadChar();
530                 int i = ReadByte();
531                 bool att = (i & 1);
532                 i >>= 1;
533
534                 if (this.enemy) {
535                         if (n != this.note || i != this.tuba_instrument || isNew) {
536                                 Ent_TubaNote_StopSound(this);
537                         }
538                 } else {
539                         this.enemy = new(tuba_note);
540                         if (Tuba_PitchStep) {
541                                 this.enemy.enemy = new(tuba_note_2);
542                         }
543                         isNew = true;
544                 }
545
546                 this.enemy.tuba_attenuate = att;
547
548                 if (isNew) {
549                         this.note = n;
550                         this.tuba_instrument = i;
551                         upd = true;
552                 }
553         }
554
555         if (f & 2) {
556                 this.enemy.origin_x = ReadCoord();
557                 this.enemy.origin_y = ReadCoord();
558                 this.enemy.origin_z = ReadCoord();
559                 setorigin(this.enemy, this.enemy.origin);
560                 if (this.enemy.enemy) {
561                         setorigin(this.enemy.enemy, this.enemy.origin);
562                 }
563         }
564
565         setthink(this, Ent_TubaNote_StopSound);
566         this.entremove = Ent_TubaNote_StopSound;
567         setthink(this.enemy, Ent_TubaNote_Think);
568         this.enemy.nextthink = time + 10;
569
570         if (upd) {
571                 Ent_TubaNote_UpdateSound(this);
572         }
573         return true;
574 }
575
576 PRECACHE(Tuba)
577 {
578         Tuba_PitchStep = autocvar_g_balance_tuba_pitchstep;
579         if (Tuba_PitchStep) {
580                 if (!checkextension("DP_SND_SOUND7_WIP2") && !checkextension("DP_SND_SOUND7")) {
581                         LOG_WARN("requested pitch shifting, but not supported by this engine build");
582                         Tuba_PitchStep = 0;
583                 }
584         }
585         for (int n = TUBA_MIN; n <= TUBA_MAX; ++n) {
586                 if (!Tuba_PitchStep || pymod(n, Tuba_PitchStep) == 0) {
587                         for (int i = 0; i < TUBA_INSTRUMENTS; ++i) {
588                                 precache_sound(TUBA_STARTNOTE(i, n));
589                         }
590                 }
591         }
592 }
593
594 #endif