tuba.qc File Reference

#include "tuba.qh"

Include dependency graph for tuba.qc:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	MAX_TUBANOTES   32
#define	TUBA_STARTNOTE(i, n)

Functions
void	Ent_TubaNote_StopSound (entity this)
void	Ent_TubaNote_Think (entity this)
void	Ent_TubaNote_UpdateSound (entity this)
	NET_HANDLE (ENT_CLIENT_TUBANOTE, bool isNew)
	PRECACHE (Tuba)
void	tubasound (entity e, bool restart)
int	W_Tuba_GetNote (entity pl, int hittype)
bool	W_Tuba_HasPlayed (entity pl,.entity weaponentity, string melody, int instrument, bool ignorepitch, float mintempo, float maxtempo)
void	W_Tuba_NoteOff (entity this)
void	W_Tuba_NoteOn (entity actor,.entity weaponentity, float hittype)
bool	W_Tuba_NoteSendEntity (entity this, entity to, int sf)
void	W_Tuba_NoteThink (entity this)

Variables
const int	TUBA_INSTRUMENTS = 3
vector	tuba_lastnotes [MAX_TUBANOTES]
float	tuba_lastnotes_cnt
float	tuba_lastnotes_last
const int	TUBA_MAX = 27
const int	TUBA_MIN = -18
entity	tuba_note
int	Tuba_PitchStep
float	tuba_smoketime

Macro Definition Documentation

MAX_TUBANOTES

#define MAX_TUBANOTES   32

Definition at line 8 of file tuba.qc.

Referenced by W_Tuba_HasPlayed(), and W_Tuba_NoteOff().

TUBA_STARTNOTE

#define TUBA_STARTNOTE	(		i,
			n )

Value:

_Sound_fixpath(W_Sound(strcat("tuba", (i ? ftos(i) : ""), "_loopnote", ftos(n))))

Definition at line 430 of file tuba.qc.

Referenced by PRECACHE(), and tubasound().

Function Documentation

Ent_TubaNote_StopSound()

void Ent_TubaNote_StopSound

(

entity

this

)

Definition at line 522 of file tuba.qc.

{
    this.enemy.nextthink = time;
    this.enemy = NULL;
}

References enemy, entity(), NULL, and time.

Referenced by NET_HANDLE().

Ent_TubaNote_Think()

void Ent_TubaNote_Think

(

entity

this

)

Definition at line 491 of file tuba.qc.

{
    float f = autocvar_cl_tuba_fadetime;
    if (f > 0)
        this.tuba_volume -= frametime * this.tuba_volume_initial / f;
    else
        this.tuba_volume = 0;
    this.nextthink = time;
    if (this.tuba_volume <= 0)
    {
        sound(this, CH_TUBA_SINGLE, SND_Null, 0, 0);
        if (this.enemy)
        {
            sound(this.enemy, CH_TUBA_SINGLE, SND_Null, 0, 0);
            delete(this.enemy);
        }
        delete(this);
    }
    else
        tubasound(this, 0);
}

References autocvar_cl_tuba_fadetime, CH_TUBA_SINGLE, enemy, entity(), frametime, nextthink, sound, time, and tubasound().

Referenced by NET_HANDLE().

Ent_TubaNote_UpdateSound()

void Ent_TubaNote_UpdateSound

(

entity

this

)

Definition at line 513 of file tuba.qc.

{
    this.enemy.tuba_volume = bound(0, VOL_BASE * autocvar_cl_tuba_volume, 1);
    this.enemy.tuba_volume_initial = this.enemy.tuba_volume;
    this.enemy.note = this.note;
    this.enemy.tuba_instrument = this.tuba_instrument;
    tubasound(this.enemy, 1);
}

References autocvar_cl_tuba_volume, bound(), enemy, entity(), tuba_instrument, tubasound(), and VOL_BASE.

Referenced by NET_HANDLE().

NET_HANDLE()

NET_HANDLE	(	ENT_CLIENT_TUBANOTE	,
		bool	isNew )

Definition at line 528 of file tuba.qc.

{
    bool upd = false;
    int f = ReadByte();
    if (f & 1)
    {
        int n = ReadChar();
        int i = ReadByte();
        bool att = i & 1;
        i >>= 1;
 
        if (this.enemy)
        {
            if (n != this.note || i != this.tuba_instrument || isNew)
                Ent_TubaNote_StopSound(this);
        }
        else
        {
            this.enemy = new(tuba_note);
            if (Tuba_PitchStep)
                this.enemy.enemy = new(tuba_note_2);
            isNew = true;
        }
 
        this.enemy.tuba_attenuate = att;
 
        if (isNew)
        {
            this.note = n;
            this.tuba_instrument = i;
            upd = true;
        }
    }
 
    if (f & 2)
    {
        this.enemy.origin = ReadVector();
        setorigin(this.enemy, this.enemy.origin);
        if (this.enemy.enemy)
            setorigin(this.enemy.enemy, this.enemy.origin);
    }
 
    setthink(this, Ent_TubaNote_StopSound);
    this.entremove = Ent_TubaNote_StopSound;
    setthink(this.enemy, Ent_TubaNote_Think);
    this.enemy.nextthink = time + 10;
 
    if (upd)
        Ent_TubaNote_UpdateSound(this);
    return true;
}

References enemy, Ent_TubaNote_StopSound(), Ent_TubaNote_Think(), Ent_TubaNote_UpdateSound(), ReadByte(), ReadVector, setthink, time, tuba_instrument, tuba_note, and Tuba_PitchStep.

PRECACHE()

PRECACHE

(

Tuba

)

Definition at line 580 of file tuba.qc.

{
    Tuba_PitchStep = autocvar_cl_tuba_pitchstep;
    if (Tuba_PitchStep)
    {
        if (!checkextension("DP_SND_SOUND7_WIP2") && !checkextension("DP_SND_SOUND7"))
        {
            LOG_WARN("requested pitch shifting, but not supported by this engine build");
            Tuba_PitchStep = 0;
        }
    }
    for (int i, n = TUBA_MIN; n <= TUBA_MAX; ++n)
        if (!Tuba_PitchStep || pymod(n, Tuba_PitchStep) == 0)
            for (i = 0; i < TUBA_INSTRUMENTS; ++i)
                precache_sound(TUBA_STARTNOTE(i, n));
}

References autocvar_cl_tuba_pitchstep, checkextension(), LOG_WARN, precache_sound(), pymod(), TUBA_INSTRUMENTS, TUBA_MAX, TUBA_MIN, Tuba_PitchStep, and TUBA_STARTNOTE.

tubasound()

void tubasound	(	entity	e,
		bool	restart )

Definition at line 438 of file tuba.qc.

{
    string snd1 = string_null;
    if (Tuba_PitchStep)
    {
        string snd2 = string_null;
        float vol1 = 1;
        float speed1 = 1;
        float vol2 = 0;
        float speed2 = 1;
 
        int m = pymod(e.note, Tuba_PitchStep);
        if (m)
        {
            if (e.note - m < TUBA_MIN)
            {
                if (restart)
                    snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note - m + Tuba_PitchStep);
                speed1 = 2.0 ** ((m - Tuba_PitchStep) / 12.0);
            }
            else if (e.note - m + Tuba_PitchStep > TUBA_MAX)
            {
                if (restart)
                    snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note - m);
                speed1 = 2.0 ** (m / 12.0);
            }
            else
            {
                if (restart)
                    snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note - m);
                vol1 = cos(M_PI_2 * m / Tuba_PitchStep);
                speed1 = 2.0 ** (m / 12.0);
                if (restart)
                    snd2 = TUBA_STARTNOTE(e.tuba_instrument, e.note - m + Tuba_PitchStep);
                vol2 = sin(M_PI_2 * m / Tuba_PitchStep);
                speed2 = 2.0 ** ((m - Tuba_PitchStep) / 12.0);
            }
        }
        else if (restart)
            snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note);
 
        sound7(e, CH_TUBA_SINGLE, snd1, e.tuba_volume * vol1, e.tuba_attenuate * autocvar_cl_tuba_attenuation, 100 * speed1, 0);
        if (vol2)
            sound7(e.enemy, CH_TUBA_SINGLE, snd2, e.tuba_volume * vol2, e.tuba_attenuate * autocvar_cl_tuba_attenuation, 100 * speed2, 0);
    }
    else
    {
        if (restart)
            snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note);
        _sound(e, CH_TUBA_SINGLE, snd1, e.tuba_volume, e.tuba_attenuate * autocvar_cl_tuba_attenuation);
    }
}

References _sound, autocvar_cl_tuba_attenuation, CH_TUBA_SINGLE, cos(), entity(), M_PI_2, pymod(), sin(), speed2, string_null, TUBA_MAX, TUBA_MIN, Tuba_PitchStep, and TUBA_STARTNOTE.

Referenced by Ent_TubaNote_Think(), and Ent_TubaNote_UpdateSound().

W_Tuba_GetNote()

int W_Tuba_GetNote	(	entity	pl,
		int	hittype )

Definition at line 136 of file tuba.qc.

{
    float movestate = 5;
    if (CS(pl).movement.x < 0)       movestate -= 3;
    else if (CS(pl).movement.x > 0)  movestate += 3;
    if (CS(pl).movement.y < 0)       movestate -= 1;
    else if (CS(pl).movement.y > 0)  movestate += 1;
 
    int note = 0;
    switch (movestate)
    {
    // layout: originally I wanted
    //   eb e  e#=f
    //   B  c  d
    //   Gb G  G#
    // but then you only use forward and right key. So to make things more
    // interesting, I swapped B with e#. Har har har...
    //   eb e  B
    // f=e# c  d
    //   Gb G  G#
        case 1: note = -6; break; // Gb
        case 2: note = -5; break; // G
        case 3: note = -4; break; // G#
        case 4: note = +5; break; // e#
        default:
        case 5: note =  0; break; // c
        case 6: note = +2; break; // d
        case 7: note = +3; break; // eb
        case 8: note = +4; break; // e
        case 9: note = -1; break; // B
    }
    if (PHYS_INPUT_BUTTON_CROUCH(pl))
        note -= 12;
    if (PHYS_INPUT_BUTTON_JUMP(pl))
        note += 12;
    if (hittype & HITTYPE_SECONDARY)
        note += 7;
 
    // we support two kinds of tubas, those tuned in Eb and those tuned in C
    // kind of tuba currently is player slot number, or team number if in
    // teamplay
    // that way, holes in the range of notes are "plugged"
    if (teamplay)
    {
        if (pl.team == NUM_TEAM_2
        ||  pl.team == NUM_TEAM_4)
            note += 3;
    }
    else
    {
        if (pl.clientcolors & 1)
            note += 3;
    }
 
    // total range of notes:
    //                       0
    //                 ***  ** ****
    //                        ***  ** ****
    //     ***  ** ****
    //            ***  ** ****
    //     ***  ********************* ****
    //     -18.........................+12
    //        ***  ********************* ****
    //     -18............................+15
    //     with jump: ... +24
    //     ... +27
    return note;
}

References CS(), entity(), HITTYPE_SECONDARY, movement, NUM_TEAM_2, NUM_TEAM_4, PHYS_INPUT_BUTTON_CROUCH, PHYS_INPUT_BUTTON_JUMP, and teamplay.

Referenced by W_Tuba_NoteOn().

W_Tuba_HasPlayed()

bool W_Tuba_HasPlayed	(	entity	pl,
		.entity	weaponentity,
		string	melody,
		int	instrument,
		bool	ignorepitch,
		float	mintempo,
		float	maxtempo )

Definition at line 13 of file tuba.qc.

{
    float n = tokenize_console(melody);
    if (n > pl.(weaponentity).tuba_lastnotes_cnt)
        return false;
    float pitchshift = 0;
 
    if (instrument >= 0 && pl.(weaponentity).tuba_instrument != instrument)
        return false;
 
    // verify notes...
    int i;
    bool nolength = false;
    for (i = 0; i < n; ++i)
    {
        vector v = pl.(weaponentity).(tuba_lastnotes[(pl.(weaponentity).tuba_lastnotes_last - i + MAX_TUBANOTES) % MAX_TUBANOTES]);
        float ai = stof(argv(n - i - 1));
        float np = floor(ai);
        if (ai == np)
            nolength = true;
        // n counts the last played notes BACKWARDS
        // .x is start
        // .y is end
        // .z is note pitch
        if (ignorepitch && i == 0)
            pitchshift = np - v.z;
        else if (v.z + pitchshift != np)
            return false;
    }
 
    // now we know the right NOTES were played
    if (!nolength)
    {
        // verify rhythm...
        float mmin, mmax;
        if (maxtempo > 0)
            mmin = 240 / maxtempo; // 60 = "0.25 means 1 sec", at 120 0.5 means 1 sec, at 240 1 means 1 sec
        else
            mmin = 0;
        if (mintempo > 0)
            mmax = 240 / mintempo; // 60 = "0.25 means 1 sec", at 120 0.5 means 1 sec, at 240 1 means 1 sec
        else
            mmax = 240; // you won't try THAT hard... (tempo 1)
        //printf("initial tempo rules: %f %f\n", mmin, mmax);
 
        float ti = 0;
        for (i = 0; i < n; ++i)
        {
            vector vi = pl.(weaponentity).(tuba_lastnotes[(pl.(weaponentity).tuba_lastnotes_last - i + MAX_TUBANOTES) % MAX_TUBANOTES]);
            float ai = stof(argv(n - i - 1));
            ti -= 1 / (ai - floor(ai));
            float tj = ti;
            for (int j = i + 1; j < n; ++j)
            {
                vector vj = pl.(weaponentity).(tuba_lastnotes[(pl.(weaponentity).tuba_lastnotes_last - j + MAX_TUBANOTES) % MAX_TUBANOTES]);
                float aj = stof(argv(n - j - 1));
                tj -= aj - floor(aj);
 
                // note i should be at m*ti+b
                // note j should be at m*tj+b
                // so:
                // we have a LINE l, so that
                // vi.x <= l(ti) <= vi.y
                // vj.x <= l(tj) <= vj.y
                // what is m?
 
                // vi.x <= vi.y <= vj.x <= vj.y
                // ti <= tj
                //printf("first note: %f to %f, should be %f\n", vi.x, vi.y, ti);
                //printf("second note: %f to %f, should be %f\n", vj.x, vj.y, tj);
                //printf("m1 = %f\n", (vi.x - vj.y) / (ti - tj));
                //printf("m2 = %f\n", (vi.y - vj.x) / (ti - tj));
                mmin = max(mmin, (vi.x - vj.y) / (ti - tj)); // lower bound
                mmax = min(mmax, (vi.y - vj.x) / (ti - tj)); // upper bound
            }
        }
 
        if (mmin > mmax) // rhythm fail
            return false;
    }
 
    pl.(weaponentity).tuba_lastnotes_cnt = 0;
 
    return true;
}

References argv(), entity(), floor(), max(), MAX_TUBANOTES, min(), stof(), tokenize_console, tuba_lastnotes, tuba_lastnotes_cnt, and vector.

Referenced by trigger_magicear_processmessage().

W_Tuba_NoteOff()

void W_Tuba_NoteOff

(

entity

this

)

Definition at line 99 of file tuba.qc.

{
    entity actor = this.owner;
    // we have a note:
    //   on: this.spawnshieldtime
    //   off: time
    //   note: this.cnt
    .entity weaponentity = this.weaponentity_fld;
    if (actor.(weaponentity).tuba_note == this)
    {
        actor.(weaponentity).tuba_lastnotes_last = (actor.(weaponentity).tuba_lastnotes_last + 1) % MAX_TUBANOTES;
        actor.(weaponentity).(tuba_lastnotes[actor.(weaponentity).tuba_lastnotes_last]) = vec3(this.spawnshieldtime, time, this.cnt);
        actor.(weaponentity).tuba_note = NULL;
        actor.(weaponentity).tuba_lastnotes_cnt = bound(0, actor.(weaponentity).tuba_lastnotes_cnt + 1, MAX_TUBANOTES);
 
        string s = trigger_magicear_processmessage_forallears(actor, 0, NULL, string_null);
        if (s != "")
        {
            // simulate a server message
            switch (this.tuba_instrument)
            {
                default:
                case 0: // Tuba
                    bprint(strcat("\{1}\{13}* ^3", actor.netname, "^3 played on the @!#%'n Tuba: ^7", s, "\n"));
                    break;
                case 1:
                    bprint(strcat("\{1}\{13}* ^3", actor.netname, "^3 played on the @!#%'n Accordeon: ^7", s, "\n"));
                    break;
                case 2:
                    bprint(strcat("\{1}\{13}* ^3", actor.netname, "^3 played on the @!#%'n Klein Bottle: ^7", s, "\n"));
                    break;
            }
        }
    }
    delete(this);
}

References bound(), bprint(), cnt, entity(), MAX_TUBANOTES, NULL, owner, spawnshieldtime, strcat(), string_null, time, trigger_magicear_processmessage_forallears(), tuba_instrument, tuba_lastnotes, tuba_lastnotes_cnt, tuba_lastnotes_last, tuba_note, vec3, and weaponentity_fld.

Referenced by W_Tuba_NoteOn(), and W_Tuba_NoteThink().

W_Tuba_NoteOn()

void W_Tuba_NoteOn	(	entity	actor,
		.entity	weaponentity,
		float	hittype )

Definition at line 262 of file tuba.qc.

{
    float n = W_Tuba_GetNote(actor, hittype);
 
    hittype = HITTYPE_SOUND;
    if (actor.(weaponentity).tuba_instrument & 1)
        hittype |= HITTYPE_SECONDARY;
    if (actor.(weaponentity).tuba_instrument & 2)
        hittype |= HITTYPE_BOUNCE;
 
    W_SetupShot(actor, weaponentity, false, 2, SND_Null, 0, WEP_CVAR(WEP_TUBA, damage), hittype | WEP_TUBA.m_id);
 
    if (actor.(weaponentity).tuba_note
    && (actor.(weaponentity).tuba_note.cnt != n || actor.(weaponentity).tuba_note.tuba_instrument != actor.(weaponentity).tuba_instrument))
        W_Tuba_NoteOff(actor.(weaponentity).tuba_note);
 
    if (!actor.(weaponentity).tuba_note)
    {
        entity note = new(tuba_note);
        note.weaponentity_fld = weaponentity;
        actor.(weaponentity).tuba_note = note;
        note.owner = note.realowner = actor;
        note.cnt = n;
        note.tuba_instrument = actor.(weaponentity).tuba_instrument;
        setthink(note, W_Tuba_NoteThink);
        note.nextthink = time;
        note.spawnshieldtime = time;
        Net_LinkEntity(note, false, 0, W_Tuba_NoteSendEntity);
    }
 
    actor.(weaponentity).tuba_note.teleport_time = time + WEP_CVAR(WEP_TUBA, refire) * 2 * W_WeaponRateFactor(actor); // so it can get prolonged safely
 
    //sound(actor, c, TUBA_NOTE(n), bound(0, VOL_BASE * autocvar_cl_tuba_volume, 1), autocvar_cl_tuba_attenuation);
    RadiusDamage(actor, actor,
        WEP_CVAR(WEP_TUBA, damage), 
        WEP_CVAR(WEP_TUBA, edgedamage),
        WEP_CVAR(WEP_TUBA, radius),
        NULL,
        NULL,
        WEP_CVAR(WEP_TUBA, force),
        hittype | WEP_TUBA.m_id,
        weaponentity,
        NULL
    );
 
    if (time > actor.(weaponentity).tuba_smoketime)
    {
        // FIXME gettaginfo(actor.(weaponentity), 0) doesn't return the real origin of the weapon
        vector org = gettaginfo(actor.(weaponentity), 0);
        if (actor.(weaponentity).tuba_instrument == 1)
            Send_Effect(EFFECT_SMOKE_RING, org + v_up * 25 + v_right * 10 + v_forward * 14, v_up * 100, 1);
        else if (actor.(weaponentity).tuba_instrument == 2)
            Send_Effect(EFFECT_SMOKE_RING, org + v_up * 50 + v_right * 10 + v_forward * 45, v_up * 100, 1);
        else
            Send_Effect(EFFECT_SMOKE_RING, org + v_up * 40 + v_right * 10 + v_forward * 14, v_up * 100, 1);
        actor.(weaponentity).tuba_smoketime = time + 0.25;
    }
}

References entity(), gettaginfo, HITTYPE_BOUNCE, HITTYPE_SECONDARY, HITTYPE_SOUND, Net_LinkEntity(), NULL, org, radius, RadiusDamage(), Send_Effect(), setthink, time, tuba_instrument, tuba_note, tuba_smoketime, v_forward, v_right, v_up, vector, W_SetupShot, W_Tuba_GetNote(), W_Tuba_NoteOff(), W_Tuba_NoteSendEntity(), W_Tuba_NoteThink(), W_WeaponRateFactor(), and WEP_CVAR.

W_Tuba_NoteSendEntity()

bool W_Tuba_NoteSendEntity	(	entity	this,
		entity	to,
		int	sf )

Definition at line 205 of file tuba.qc.

{
    msg_entity = to;
    if (!sound_allowed(MSG_ONE, this.realowner))
        return false;
 
    WriteHeader(MSG_ENTITY, ENT_CLIENT_TUBANOTE);
    WriteByte(MSG_ENTITY, sf);
    if (sf & 1)
    {
        WriteChar(MSG_ENTITY, this.cnt);
        int f = 0;
        f |= 1 * (this.realowner != to);
        f |= 2 * this.tuba_instrument;
        WriteByte(MSG_ENTITY, f);
    }
    if (sf & 2)
        WriteVector(MSG_ENTITY, this.origin);
    return true;
}

References cnt, entity(), MSG_ENTITY, msg_entity, MSG_ONE, origin, realowner, sound_allowed(), tuba_instrument, WriteByte(), WriteChar(), and WriteHeader.

Referenced by W_Tuba_NoteOn().

W_Tuba_NoteThink()

void W_Tuba_NoteThink

(

entity

this

)

Definition at line 226 of file tuba.qc.

{
    if (time > this.teleport_time)
    {
        W_Tuba_NoteOff(this);
        return;
    }
    this.nextthink = time;
 
    float vol0, vol1;
    vector dir0, dir1;
    vector v;
    float dist_mult = WEP_CVAR(WEP_TUBA, attenuation) / autocvar_snd_soundradius;
    FOREACH_CLIENT(IS_REAL_CLIENT(it) && it != this.realowner,
    {
        v = this.origin - (it.origin + it.view_ofs);
        vol0 = max(0, 1 - vlen(v) * dist_mult);
        dir0 = normalize(v);
        v = this.realowner.origin - (it.origin + it.view_ofs);
        vol1 = max(0, 1 - vlen(v) * dist_mult);
        dir1 = normalize(v);
        if (fabs(vol0 - vol1) > 0.005) // 0.5 percent change in volume
        {
            setorigin(this, this.realowner.origin);
            this.SendFlags |= 2;
            break;
        }
        if (dir0 * dir1 < 0.9994) // 2 degrees change in angle
        {
            setorigin(this, this.realowner.origin);
            this.SendFlags |= 2;
            break;
        }
    });
}

References autocvar_snd_soundradius, entity(), fabs(), FOREACH_CLIENT, IS_REAL_CLIENT, max(), nextthink, normalize(), origin, realowner, SendFlags, teleport_time, time, vector, vlen(), W_Tuba_NoteOff(), and WEP_CVAR.

Referenced by W_Tuba_NoteOn().

Variable Documentation

TUBA_INSTRUMENTS

const int TUBA_INSTRUMENTS = 3

Definition at line 434 of file tuba.qc.

Referenced by PRECACHE().

tuba_lastnotes

vector tuba_lastnotes[MAX_TUBANOTES]

Definition at line 11 of file tuba.qc.

Referenced by W_Tuba_HasPlayed(), and W_Tuba_NoteOff().

tuba_lastnotes_cnt

float tuba_lastnotes_cnt

Definition at line 10 of file tuba.qc.

Referenced by W_Tuba_HasPlayed(), and W_Tuba_NoteOff().

tuba_lastnotes_last

float tuba_lastnotes_last

Definition at line 9 of file tuba.qc.

Referenced by W_Tuba_NoteOff().

TUBA_MAX

const int TUBA_MAX = 27

Definition at line 433 of file tuba.qc.

Referenced by PRECACHE(), and tubasound().

TUBA_MIN

const int TUBA_MIN = -18

Definition at line 432 of file tuba.qc.

Referenced by PRECACHE(), and tubasound().

tuba_note

entity tuba_note

Definition at line 5 of file tuba.qc.

Referenced by bot_cmd_debug_assert_canfire(), NET_HANDLE(), W_Tuba_NoteOff(), and W_Tuba_NoteOn().

Tuba_PitchStep

int Tuba_PitchStep

Definition at line 436 of file tuba.qc.

Referenced by NET_HANDLE(), PRECACHE(), and tubasound().

tuba_smoketime

float tuba_smoketime

Definition at line 6 of file tuba.qc.

Referenced by W_Tuba_NoteOn().