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