void CL_InitTEnts(void)
{
cl_sfx_tink1 = S_PrecacheSound ("weapons/tink1.wav");
cl_sfx_ric1 = S_PrecacheSound ("weapons/ric1.wav");
cl_sfx_ric2 = S_PrecacheSound ("weapons/ric2.wav");
cl_sfx_ric3 = S_PrecacheSound ("weapons/ric3.wav");
cl_sfx_r_exp3 = S_PrecacheSound ("weapons/r_exp3.wav");
}
void QCBUILTIN PF_soundlength (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
const char *sample = PR_GetStringOfs(prinst, OFS_PARM0);
sfx_t *sfx = S_PrecacheSound(sample);
if (sfx && sfx->loadstate == SLS_LOADING)
COM_WorkerPartialSync(sfx, &sfx->loadstate, SLS_LOADING);
if (!sfx || sfx->loadstate != SLS_LOADED)
G_FLOAT(OFS_RETURN) = 0;
else
{
sfxcache_t cachebuf, *cache;
if (sfx->decoder.querydata)
{
G_FLOAT(OFS_RETURN) = sfx->decoder.querydata(sfx, NULL);
return;
}
else if (sfx->decoder.decodedata)
cache = sfx->decoder.decodedata(sfx, &cachebuf, 0x7ffffffe, 0);
else
cache = sfx->decoder.buf;
if (!cache)
G_FLOAT(OFS_RETURN) = 0;
else
G_FLOAT(OFS_RETURN) = (cache->soundoffset+cache->length) / (float)snd_speed;
}
}
static void VR_MenuPlaySound(const char *sound, float fvol)
{
sfx_t *sfx = S_PrecacheSound( sound );
if ( sfx ) {
S_StartSound( cl.viewentity, 0, sfx, vec3_origin, fvol, 1 );
}
}
/*
=================
CL_ParseTEnt
=================
*/
void CL_InitTEnts (void)
{
cl_sfx_wizhit = S_PrecacheSound ("wizard/hit.wav");
cl_sfx_knighthit = S_PrecacheSound ("hknight/hit.wav");
cl_sfx_tink1 = S_PrecacheSound ("weapons/tink1.wav");
cl_sfx_ric1 = S_PrecacheSound ("weapons/ric1.wav");
cl_sfx_ric2 = S_PrecacheSound ("weapons/ric2.wav");
cl_sfx_ric3 = S_PrecacheSound ("weapons/ric3.wav");
cl_sfx_r_exp3 = S_PrecacheSound ("weapons/r_exp3.wav");
#ifdef QUAKE2
cl_sfx_imp = S_PrecacheSound ("shambler/sattck1.wav");
cl_sfx_rail = S_PrecacheSound ("weapons/lstart.wav");
#endif
}
/*
=================
CL_ParseTEnt
=================
*/
void CL_InitTEnts (void)
{
cl_sfx_wizhit = S_PrecacheSound ("wizard/hit.wav");
cl_sfx_knighthit = S_PrecacheSound ("hknight/hit.wav");
cl_sfx_tink1 = S_PrecacheSound ("weapons/tink1.wav");
cl_sfx_ric1 = S_PrecacheSound ("weapons/ric1.wav");
cl_sfx_ric2 = S_PrecacheSound ("weapons/ric2.wav");
cl_sfx_ric3 = S_PrecacheSound ("weapons/ric3.wav");
cl_sfx_r_exp3 = S_PrecacheSound ("weapons/r_exp3.wav");
}
/*
=================
CL_InitTEnts
=================
*/
void CL_InitTEnts (void)
{
extern sfx_t *ambient_sfx[NUM_AMBIENTS];
Cvar_Register (&cl_fakeshaft);
Cvar_Register (&r_shaftalpha);
cl_sfx_wizhit = S_PrecacheSound ("wizard/hit.wav");
cl_sfx_knighthit = S_PrecacheSound ("hknight/hit.wav");
cl_sfx_tink1 = S_PrecacheSound ("weapons/tink1.wav");
cl_sfx_ric1 = S_PrecacheSound ("weapons/ric1.wav");
cl_sfx_ric2 = S_PrecacheSound ("weapons/ric2.wav");
cl_sfx_ric3 = S_PrecacheSound ("weapons/ric3.wav");
cl_sfx_r_exp3 = S_PrecacheSound ("weapons/r_exp3.wav");
ambient_sfx[AMBIENT_WATER] = S_PrecacheSound ("ambience/water1.wav");
ambient_sfx[AMBIENT_SKY] = S_PrecacheSound ("ambience/wind2.wav");
}
static void S_Restart_f (void)
{
Com_DPrintf("Restarting sound system....\n");
Cache_Flush();
S_StopAllSounds (true);
S_Shutdown();
Com_DPrintf("sound: Shutdown OK\n");
if (!S_Startup()) {
snd_initialized = false;
return;
}
ambient_sfx[AMBIENT_WATER] = S_PrecacheSound ("ambience/water1.wav");
ambient_sfx[AMBIENT_SKY] = S_PrecacheSound ("ambience/wind2.wav");
S_StopAllSounds (true);
if (developer.value)
S_SoundInfo_f();
}
void S_LocalSound (char *sound)
{
sfx_t *sfx;
if (!snd_initialized || s_nosound.value)
return;
if (!(sfx = S_PrecacheSound (sound))) {
Com_Printf ("S_LocalSound: can't cache %s\n", sound);
return;
}
S_StartSound (cl.playernum+1, -1, sfx, vec3_origin, 1, 0);
}
void S_LocalSound (char *sound)
{
sfx_t *sfx;
if (!sound_started || s_nosound.value)
return;
sfx = S_PrecacheSound (sound);
if (!sfx)
{
Com_Printf ("S_LocalSound: can't cache %s\n", sound);
return;
}
S_StartSound (cl.playernum+1, -1, sfx, vec3_origin, 1, ATTN_NONE);
}
static void S_Play_f (void)
{
int i;
char name[256];
sfx_t *sfx;
if (!snd_initialized || s_nosound.value)
return;
for (i = 1; i < Cmd_Argc(); i++) {
strlcpy (name, Cmd_Argv(i), sizeof (name));
COM_DefaultExtension (name, ".wav");
sfx = S_PrecacheSound(name);
S_StartSound(SELF_SOUND, 0, sfx, listener_origin, 1.0, 0.0);
}
}
void S_LocalSoundWithVol(char *sound, float volume)
{
sfx_t *sfx;
clamp(volume, 0, 1.0);
if (!snd_initialized || s_nosound.value)
return;
if (!(sfx = S_PrecacheSound (sound))) {
Com_Printf ("S_LocalSound: can't cache %s\n", sound);
return;
}
S_StartSound (cl.playernum+1, -1, sfx, vec3_origin, volume, 1);
}
void S_LocalSound (char *sound)
{
sfx_t *sfx;
if (nosound.value)
return;
if (!sound_started)
return;
sfx = S_PrecacheSound (sound);
if (!sfx)
{
Con_Printf ("S_LocalSound: can't cache %s\n", sound);
return;
}
S_StartSound (cl.viewentity, -1, sfx, vec3_origin, 1, 1);
}
static void S_PlayVol_f (void)
{
int i;
float vol;
char name[256];
sfx_t *sfx;
if (!snd_initialized || s_nosound.value)
return;
for (i = 1; i < Cmd_Argc(); i += 2) {
strlcpy (name, Cmd_Argv(i), sizeof (name));
COM_DefaultExtension (name, ".wav");
sfx = S_PrecacheSound(name);
vol = Q_atof(Cmd_Argv(i + 1));
// ezhfan:
// pnum+1 changed to SELF_SOUND to make sound not to disappear
S_StartSound(SELF_SOUND, 0, sfx, listener_origin, vol, 0.0);
}
}
static void S_Play (void)
{
static int hash = 345;
int i;
char name[256];
sfx_t *sfx;
i = 1;
while (i < Cmd_Argc())
{
q_strlcpy(name, Cmd_Argv(i), sizeof(name));
if (!Q_strrchr(Cmd_Argv(i), '.'))
{
q_strlcat(name, ".wav", sizeof(name));
}
sfx = S_PrecacheSound(name);
S_StartSound(hash++, 0, sfx, listener_origin, 1.0, 1.0);
i++;
}
}
void
S_LocalSound(const char *sound)
{
sfx_t *sfx;
if (nosound.value)
return;
if (!sound_started)
return;
sfx = S_PrecacheSound(sound);
if (!sfx) {
Con_Printf("%s: can't cache %s\n", __func__, sound);
return;
}
#ifdef NQ_HACK
S_StartSound(cl.viewentity, -1, sfx, vec3_origin, 1, 1);
#endif
#ifdef QW_HACK
S_StartSound(cl.playernum + 1, -1, sfx, vec3_origin, 1, 1);
#endif
}
static void S_PlayVol (void)
{
static int hash = 543;
int i;
float vol;
char name[256];
sfx_t *sfx;
i = 1;
while (i < Cmd_Argc())
{
q_strlcpy(name, Cmd_Argv(i), sizeof(name));
if (!Q_strrchr(Cmd_Argv(i), '.'))
{
q_strlcat(name, ".wav", sizeof(name));
}
sfx = S_PrecacheSound(name);
vol = Q_atof(Cmd_Argv(i + 1));
S_StartSound(hash++, 0, sfx, listener_origin, vol, 1.0);
i += 2;
}
}
int CEngineTool::StartSound(
int iUserData,
bool staticsound,
int iEntIndex,
int iChannel,
const char *pSample,
float flVolume,
soundlevel_t iSoundlevel,
const Vector& origin,
const Vector& direction,
int iFlags /*= 0*/,
int iPitch /*= PITCH_NORM*/,
bool bUpdatePositions /*= true*/,
float delay /*= 0.0f*/,
int speakerentity /*= -1*/ )
{
StartSoundParams_t params;
params.userdata = iUserData;
params.staticsound = staticsound;
params.soundsource = iEntIndex;
params.entchannel = iChannel;
params.pSfx = S_PrecacheSound( pSample );
params.origin = origin;
params.direction = direction;
params.bUpdatePositions = bUpdatePositions;
params.fvol = flVolume;
params.soundlevel = iSoundlevel;
params.flags = iFlags;
params.pitch = iPitch;
params.fromserver = false;
params.delay = delay;
params.speakerentity = speakerentity;
params.suppressrecording = true;
int guid = S_StartSound( params );
return guid;
}
static void
CL_TEnts_Precache (int phase)
{
if (!phase)
return;
cl_sfx_wizhit = S_PrecacheSound ("wizard/hit.wav");
cl_sfx_knighthit = S_PrecacheSound ("hknight/hit.wav");
cl_sfx_tink1 = S_PrecacheSound ("weapons/tink1.wav");
cl_sfx_ric1 = S_PrecacheSound ("weapons/ric1.wav");
cl_sfx_ric2 = S_PrecacheSound ("weapons/ric2.wav");
cl_sfx_ric3 = S_PrecacheSound ("weapons/ric3.wav");
cl_sfx_r_exp3 = S_PrecacheSound ("weapons/r_exp3.wav");
cl_mod_bolt = Mod_ForName ("progs/bolt.mdl", true);
cl_mod_bolt2 = Mod_ForName ("progs/bolt2.mdl", true);
cl_mod_bolt3 = Mod_ForName ("progs/bolt3.mdl", true);
cl_spr_explod = Mod_ForName ("progs/s_explod.spr", true);
cl_mod_beam = Mod_ForName ("progs/beam.mdl", false);
if (!cl_mod_beam)
cl_mod_beam = cl_mod_bolt;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDemoActionPlaySoundStart::FireAction( void )
{
Vector vDummyOrigin;
vDummyOrigin.Init();
CSfxTable *pSound = (CSfxTable*)S_PrecacheSound(GetSoundName());
if ( pSound )
{
StartSoundParams_t params;
params.staticsound = false;
params.soundsource = cl.m_nViewEntity;
params.entchannel = CHAN_AUTO;
params.pSfx = pSound;
params.origin = vDummyOrigin;
params.fvol = 1.0f;
params.soundlevel = SNDLVL_IDLE;
params.flags = 0;
params.pitch = PITCH_NORM;
S_StartSound( params );
}
SetFinishedAction( true );
}
/*
=================
CL_ParseTEnt
=================
*/
void CL_InitTEnts (void)
{
cl_sfx_wizhit = S_PrecacheSound ("wizard/hit.wav");
cl_sfx_knighthit = S_PrecacheSound ("hknight/hit.wav");
cl_sfx_tink1 = S_PrecacheSound ("weapons/tink1.wav");
cl_sfx_r_exp3 = S_PrecacheSound ("weapons/r_exp3.wav");
cl_sfx_thunder = S_PrecacheSound ("ambience/thunder1.wav");
//normal rics
cl_sfx_ric1 = S_PrecacheSound ("weapons/rics/ric1.wav");
cl_sfx_ric2 = S_PrecacheSound ("weapons/rics/ric2.wav");
cl_sfx_ric3 = S_PrecacheSound ("weapons/rics/ric3.wav");
// wood rics
cl_sfx_wric1 = S_PrecacheSound ("weapons/rics/wood_ric1.wav");
cl_sfx_wric2 = S_PrecacheSound ("weapons/rics/wood_ric2.wav");
cl_sfx_wric3 = S_PrecacheSound ("weapons/rics/wood_ric3.wav");
// metall rics
cl_sfx_mric1 = S_PrecacheSound ("weapons/rics/metal_ric1.wav");
cl_sfx_mric2 = S_PrecacheSound ("weapons/rics/metal_ric2.wav");
cl_sfx_mric3 = S_PrecacheSound ("weapons/rics/metal_ric3.wav");
#ifdef QUAKE2
cl_sfx_imp = S_PrecacheSound ("shambler/sattck1.wav");
cl_sfx_rail = S_PrecacheSound ("weapons/lstart.wav");
#endif
}
/*
=================
CL_ParseTEnt
=================
*/
void CL_InitTEnts (void)
{
cl_sfx_wizhit = S_PrecacheSound ("wizard/hit.wav");
cl_sfx_knighthit = S_PrecacheSound ("hknight/hit.wav");
cl_sfx_tink1 = S_PrecacheSound ("weapons/tink1.wav");
cl_sfx_ric1 = S_PrecacheSound ("weapons/ric1.wav");
cl_sfx_ric2 = S_PrecacheSound ("weapons/ric2.wav");
cl_sfx_ric3 = S_PrecacheSound ("weapons/ric3.wav");
cl_sfx_r_exp3 = S_PrecacheSound ("weapons/r_exp3.wav");
cl_sfx_imp = S_PrecacheSound ("shambler/sattck1.wav");
cl_sfx_rail = S_PrecacheSound ("weapons/lstart.wav");
cl_sfx_bloodhit1 = S_PrecacheSound ("player/tornoff2.wav");
cl_sfx_bloodhit2 = S_PrecacheSound ("demon/dhit2.wav");
cl_sfx_bloodhit3 = S_PrecacheSound ("zombie/z_miss.wav");
}
/*
==================
CL_ParseServerInfo
==================
*/
void
CL_ParseServerInfo(void)
{
char *level;
const char *mapname;
int i, maxlen;
int nummodels, numsounds;
char model_precache[MAX_MODELS][MAX_QPATH];
char sound_precache[MAX_SOUNDS][MAX_QPATH];
Con_DPrintf("Serverinfo packet received.\n");
//
// wipe the client_state_t struct
//
CL_ClearState();
// parse protocol version number
i = MSG_ReadLong();
if (!Protocol_Known(i)) {
Con_Printf("Server returned unknown protocol version %i\n", i);
return;
}
cl.protocol = i;
// parse maxclients
cl.maxclients = MSG_ReadByte();
if (cl.maxclients < 1 || cl.maxclients > MAX_SCOREBOARD) {
Con_Printf("Bad maxclients (%u) from server\n", cl.maxclients);
return;
}
cl.players = Hunk_AllocName(cl.maxclients * sizeof(*cl.players), "players");
// parse gametype
cl.gametype = MSG_ReadByte();
// parse signon message
level = cl.levelname;
maxlen = sizeof(cl.levelname);
snprintf(level, maxlen, "%s", MSG_ReadString());
// seperate the printfs so the server message can have a color
Con_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36"
"\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
Con_Printf("%c%s\n", 2, level);
Con_Printf("Using protocol %i\n", cl.protocol);
//
// first we go through and touch all of the precache data that still
// happens to be in the cache, so precaching something else doesn't
// needlessly purge it
//
// precache models
memset(cl.model_precache, 0, sizeof(cl.model_precache));
for (nummodels = 1;; nummodels++) {
char *in, *model;
in = MSG_ReadString();
if (!in[0])
break;
if (nummodels == max_models(cl.protocol)) {
Host_Error("Server sent too many model precaches (max = %d)",
max_models(cl.protocol));
return;
}
model = model_precache[nummodels];
maxlen = sizeof(model_precache[0]);
snprintf(model, maxlen, "%s", in);
Mod_TouchModel(model);
}
// precache sounds
memset(cl.sound_precache, 0, sizeof(cl.sound_precache));
for (numsounds = 1;; numsounds++) {
char *in, *sound;
in = MSG_ReadString();
if (!in[0])
break;
if (numsounds == max_sounds(cl.protocol)) {
Host_Error("Server sent too many sound precaches (max = %d)",
max_sounds(cl.protocol));
return;
}
sound = sound_precache[numsounds];
maxlen = sizeof(sound_precache[0]);
snprintf(sound, maxlen, "%s", in);
S_TouchSound(sound);
}
// copy the naked name of the map file to the cl structure
mapname = COM_SkipPath(model_precache[1]);
COM_StripExtension(mapname, cl.mapname, sizeof(cl.mapname));
//
// now we try to load everything else until a cache allocation fails
//
for (i = 1; i < nummodels; i++) {
cl.model_precache[i] = Mod_ForName(model_precache[i], false);
if (cl.model_precache[i] == NULL) {
Con_Printf("Model %s not found\n", model_precache[i]);
return;
}
CL_KeepaliveMessage();
}
S_BeginPrecaching();
for (i = 1; i < numsounds; i++) {
cl.sound_precache[i] = S_PrecacheSound(sound_precache[i]);
CL_KeepaliveMessage();
}
S_EndPrecaching();
// local state
cl_entities[0].model = cl.model_precache[1];
cl.worldmodel = BrushModel(cl_entities[0].model);
R_NewMap();
Hunk_Check(); // make sure nothing is hurt
noclip_anglehack = false; // noclip is turned off at start
}
/*
================
S_Init
================
*/
void S_Init (void)
{
int i;
if (snd_initialized)
{
Con_Printf("Sound is already initialized\n");
return;
}
Cvar_RegisterVariable(&nosound);
Cvar_RegisterVariable(&sfxvolume);
Cvar_RegisterVariable(&precache);
Cvar_RegisterVariable(&loadas8bit);
Cvar_RegisterVariable(&bgmvolume);
Cvar_RegisterVariable(&ambient_level);
Cvar_RegisterVariable(&ambient_fade);
Cvar_RegisterVariable(&snd_noextraupdate);
Cvar_RegisterVariable(&snd_show);
Cvar_RegisterVariable(&_snd_mixahead);
Cvar_RegisterVariable(&sndspeed);
Cvar_RegisterVariable(&snd_mixspeed);
Cvar_RegisterVariable(&snd_filterquality);
if (safemode || COM_CheckParm("-nosound"))
return;
Con_Printf("\nSound Initialization\n");
Cmd_AddCommand("play", S_Play);
Cmd_AddCommand("playvol", S_PlayVol);
Cmd_AddCommand("stopsound", S_StopAllSoundsC);
Cmd_AddCommand("soundlist", S_SoundList);
Cmd_AddCommand("soundinfo", S_SoundInfo_f);
i = COM_CheckParm("-sndspeed");
if (i && i < com_argc-1)
{
Cvar_SetQuick (&sndspeed, com_argv[i+1]);
}
i = COM_CheckParm("-mixspeed");
if (i && i < com_argc-1)
{
Cvar_SetQuick (&snd_mixspeed, com_argv[i+1]);
}
if (host_parms->memsize < 0x800000)
{
Cvar_SetQuick (&loadas8bit, "1");
Con_Printf ("loading all sounds as 8bit\n");
}
Cvar_SetCallback(&sfxvolume, SND_Callback_sfxvolume);
Cvar_SetCallback(&snd_filterquality, &SND_Callback_snd_filterquality);
SND_InitScaletable ();
known_sfx = (sfx_t *) Hunk_AllocName (MAX_SFX*sizeof(sfx_t), "sfx_t");
num_sfx = 0;
snd_initialized = true;
S_Startup ();
if (sound_started == 0)
return;
// provides a tick sound until washed clean
// if (shm->buffer)
// shm->buffer[4] = shm->buffer[5] = 0x7f; // force a pop for debugging
ambient_sfx[AMBIENT_WATER] = S_PrecacheSound ("ambience/water1.wav");
ambient_sfx[AMBIENT_SKY] = S_PrecacheSound ("ambience/wind2.wav");
S_CodecInit ();
S_StopAllSounds (true);
}
/*
================
S_Init
================
*/
void S_Init (void)
{
Con_Printf("\nSound Initialization\n");
Cvar_RegisterVariable(&precache);
if (COM_CheckParm("-nosound"))
return;
if (COM_CheckParm("-simsound"))
fakedma = true;
Cmd_AddCommand("play", S_Play);
Cmd_AddCommand("playvol", S_PlayVol);
Cmd_AddCommand("stopsound", S_StopAllSoundsC);
Cmd_AddCommand("soundlist", S_SoundList);
Cmd_AddCommand("soundinfo", S_SoundInfo_f);
Cvar_RegisterVariable(&nosound);
Cvar_RegisterVariable(&volume);
Cvar_RegisterVariable(&loadas8bit);
Cvar_RegisterVariable(&bgmvolume);
Cvar_RegisterVariable(&bgmtype);
Cvar_RegisterVariable(&bgmbuffer);
Cvar_RegisterVariable(&ambient_level);
Cvar_RegisterVariable(&ambient_fade);
Cvar_RegisterVariable(&snd_noextraupdate);
Cvar_RegisterVariable(&snd_show);
Cvar_RegisterVariable(&_snd_mixahead);
if (host_parms.memsize < 0x800000)
{
Cvar_Set ("loadas8bit", "1");
Con_Printf ("loading all sounds as 8bit\n");
}
snd_initialized = true;
S_Startup ();
SND_InitScaletable ();
known_sfx = Hunk_AllocName (MAX_SFX*sizeof(sfx_t), "sfx_t");
num_sfx = 0;
// create a piece of DMA memory
if (fakedma)
{
shm = (void *) Hunk_AllocName(sizeof(*shm), "shm");
shm->splitbuffer = 0;
shm->samplebits = 16;
shm->speed = 22050;
shm->channels = 2;
shm->samples = 32768;
shm->samplepos = 0;
shm->soundalive = true;
shm->gamealive = true;
shm->submission_chunk = 1;
shm->buffer = Hunk_AllocName(1<<16, "shmbuf");
}
Con_Printf ("Sound sampling rate: %i\n", shm->speed);
// provides a tick sound until washed clean
// if (shm->buffer)
// shm->buffer[4] = shm->buffer[5] = 0x7f; // force a pop for debugging
ambient_sfx[AMBIENT_WATER] = S_PrecacheSound ("ambience/water1.wav");
ambient_sfx[AMBIENT_SKY] = S_PrecacheSound ("ambience/wind2.wav");
S_StopAllSounds (true);
}
/*
==================
CL_ParseServerInfo
==================
*/
void CL_ParseServerInfo (void)
{
const char *str;
int i;
int nummodels, numsounds;
char model_precache[MAX_MODELS][MAX_QPATH];
char sound_precache[MAX_SOUNDS][MAX_QPATH];
Con_DPrintf ("Serverinfo packet received.\n");
//
// wipe the client_state_t struct
//
CL_ClearState ();
// parse protocol version number
i = MSG_ReadLong ();
//johnfitz -- support multiple protocols
if (i != PROTOCOL_NETQUAKE && i != PROTOCOL_FITZQUAKE) {
Con_Printf ("\n"); //becuase there's no newline after serverinfo print
Host_Error ("Server returned version %i, not %i or %i\n", i, PROTOCOL_NETQUAKE, PROTOCOL_FITZQUAKE);
}
cl.protocol = i;
//johnfitz
// parse maxclients
cl.maxclients = MSG_ReadByte ();
if (cl.maxclients < 1 || cl.maxclients > MAX_SCOREBOARD)
{
Con_Printf("Bad maxclients (%u) from server\n", cl.maxclients);
return;
}
cl.scores = (scoreboard_t *) Hunk_AllocName (cl.maxclients*sizeof(*cl.scores), "scores");
// parse gametype
cl.gametype = MSG_ReadByte ();
// parse signon message
str = MSG_ReadString ();
q_strlcpy (cl.levelname, str, sizeof(cl.levelname));
// seperate the printfs so the server message can have a color
Con_Printf ("\n%s\n", Con_Quakebar(40)); //johnfitz
Con_Printf ("%c%s\n", 2, str);
//johnfitz -- tell user which protocol this is
Con_Printf ("Using protocol %i\n", i);
// first we go through and touch all of the precache data that still
// happens to be in the cache, so precaching something else doesn't
// needlessly purge it
// precache models
memset (cl.model_precache, 0, sizeof(cl.model_precache));
for (nummodels = 1 ; ; nummodels++)
{
str = MSG_ReadString ();
if (!str[0])
break;
if (nummodels==MAX_MODELS)
{
Con_Printf ("Server sent too many model precaches\n");
return;
}
q_strlcpy (model_precache[nummodels], str, MAX_QPATH);
Mod_TouchModel (str);
}
//johnfitz -- check for excessive models
if (nummodels >= 256)
Con_Warning ("%i models exceeds standard limit of 256.\n", nummodels);
//johnfitz
// precache sounds
memset (cl.sound_precache, 0, sizeof(cl.sound_precache));
for (numsounds = 1 ; ; numsounds++)
{
str = MSG_ReadString ();
if (!str[0])
break;
if (numsounds==MAX_SOUNDS)
{
Con_Printf ("Server sent too many sound precaches\n");
return;
}
q_strlcpy (sound_precache[numsounds], str, MAX_QPATH);
S_TouchSound (str);
}
//johnfitz -- check for excessive sounds
if (numsounds >= 256)
Con_Warning ("%i sounds exceeds standard limit of 256.\n", numsounds);
//johnfitz
//
// now we try to load everything else until a cache allocation fails
//
// copy the naked name of the map file to the cl structure -- O.S
COM_StripExtension (COM_SkipPath(model_precache[1]), cl.mapname, sizeof(cl.mapname));
for (i = 1; i < nummodels; i++)
{
cl.model_precache[i] = Mod_ForName (model_precache[i], false);
if (cl.model_precache[i] == NULL)
{
Con_Printf("Model %s not found\n", model_precache[i]);
return;
}
CL_KeepaliveMessage ();
}
S_BeginPrecaching ();
for (i = 1; i < numsounds; i++)
{
cl.sound_precache[i] = S_PrecacheSound (sound_precache[i]);
CL_KeepaliveMessage ();
}
S_EndPrecaching ();
// local state
cl_entities[0].model = cl.worldmodel = cl.model_precache[1];
R_NewMap ();
//johnfitz -- clear out string; we don't consider identical
//messages to be duplicates if the map has changed in between
con_lastcenterstring[0] = 0;
//johnfitz
Hunk_Check (); // make sure nothing is hurt
noclip_anglehack = false; // noclip is turned off at start
warn_about_nehahra_protocol = true; //johnfitz -- warn about nehahra protocol hack once per server connection
//johnfitz -- reset developer stats
memset(&dev_stats, 0, sizeof(dev_stats));
memset(&dev_peakstats, 0, sizeof(dev_peakstats));
memset(&dev_overflows, 0, sizeof(dev_overflows));
}
/*
==================
CL_ParseServerInfo
==================
*/
static void CL_ParseServerInfo (void)
{
const char *str;
int i;
int nummodels, numsounds;
char model_precache[MAX_MODELS][MAX_QPATH];
char sound_precache[MAX_SOUNDS][MAX_QPATH];
// rjr edict_t *ent;
Con_DPrintf ("Serverinfo packet received.\n");
//
// wipe the client_state_t struct
//
CL_ClearState ();
// parse protocol version number
cl_protocol = MSG_ReadLong ();
switch (cl_protocol)
{
case PROTOCOL_RAVEN_111:
case PROTOCOL_RAVEN_112:
case PROTOCOL_UQE_113:
Con_Printf ("\nServer using protocol %i\n", cl_protocol);
break;
default:
Con_Printf ("\nServer returned version %i, not %i or %i\n",
cl_protocol, PROTOCOL_RAVEN_112, PROTOCOL_UQE_113);
return;
}
// parse maxclients
cl.maxclients = MSG_ReadByte ();
if (cl.maxclients < 1 || cl.maxclients > MAX_CLIENTS)
{
Con_Printf("Bad maxclients (%d) from server\n", cl.maxclients);
return;
}
cl.scores = (scoreboard_t *) Hunk_AllocName (cl.maxclients*sizeof(*cl.scores), "scores");
// parse gametype
cl.gametype = MSG_ReadByte ();
if (cl.gametype == GAME_DEATHMATCH && cl_protocol > PROTOCOL_RAVEN_111)
sv_kingofhill = MSG_ReadShort ();
// parse signon message
str = MSG_ReadString ();
q_strlcpy (cl.levelname, str, sizeof(cl.levelname));
// seperate the printfs so the server message can have a color
Con_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
Con_Printf ("%c%s\n", 2, str);
//
// first we go through and touch all of the precache data that still
// happens to be in the cache, so precaching something else doesn't
// needlessly purge it
//
// precache models
memset (cl.model_precache, 0, sizeof(cl.model_precache));
for (nummodels = 1 ; ; nummodels++)
{
str = MSG_ReadString ();
if (!str[0])
break;
if (nummodels == MAX_MODELS)
{
Con_Printf ("Server sent too many model precaches\n");
return;
}
q_strlcpy (model_precache[nummodels], str, MAX_QPATH);
Mod_TouchModel (str);
}
// precache sounds
memset (cl.sound_precache, 0, sizeof(cl.sound_precache));
for (numsounds = 1 ; ; numsounds++)
{
str = MSG_ReadString ();
if (!str[0])
break;
if (numsounds == MAX_SOUNDS)
{
Con_Printf ("Server sent too many sound precaches\n");
return;
}
q_strlcpy (sound_precache[numsounds], str, MAX_QPATH);
S_TouchSound (str);
}
//
// now we try to load everything else until a cache allocation fails
//
if (precache.integer)
{
total_loading_size = nummodels + numsounds;
current_loading_size = 1;
loading_stage = 2;
}
// copy the naked name of the map file to the cl structure
COM_StripExtension (COM_SkipPath(model_precache[1]), cl.mapname, sizeof(cl.mapname));
//always precache the world!!!
cl.model_precache[1] = Mod_ForName (model_precache[1], false);
for (i = 2; i < nummodels; i++)
{
if (precache.integer)
{
cl.model_precache[i] = Mod_ForName (model_precache[i], false);
current_loading_size++;
D_ShowLoadingSize();
}
else
cl.model_precache[i] = (model_t *)Mod_FindName (model_precache[i]);
if (cl.model_precache[i] == NULL)
{
Host_Error("Model %s not found", model_precache[i]);
return;
}
CL_KeepaliveMessage ();
}
player_models[0] = (model_t *)Mod_FindName ("models/paladin.mdl");
// Note: old demo doesnt have necro and crusader classes. add
// a GAME_OLD_DEMO flag check ?
player_models[1] = (model_t *)Mod_FindName ("models/crusader.mdl");
player_models[2] = (model_t *)Mod_FindName ("models/necro.mdl");
player_models[3] = (model_t *)Mod_FindName ("models/assassin.mdl");
if (gameflags & GAME_PORTALS)
player_models[4] = (model_t *)Mod_FindName ("models/succubus.mdl");
S_BeginPrecaching ();
for (i = 1; i < numsounds; i++)
{
cl.sound_precache[i] = S_PrecacheSound (sound_precache[i]);
if (precache.integer)
{
current_loading_size++;
D_ShowLoadingSize();
}
CL_KeepaliveMessage ();
}
S_EndPrecaching ();
total_loading_size = 0;
loading_stage = 0;
// local state
cl_entities[0].model = cl.worldmodel = cl.model_precache[1];
R_NewMap ();
if (!sv.active)
{
PR_LoadStrings();
}
PR_LoadPuzzleStrings();
// mission pack, objectives strings
if (gameflags & GAME_PORTALS)
PR_LoadInfoStrings();
Hunk_Check (); // make sure nothing is hurt
// we connected to the server, make sure the mouse is going - S.A.
menu_disabled_mouse = false;
IN_ActivateMouse();
}
/*
==================
NQD_ParseServerData
==================
*/
static void NQD_ParseServerData (void)
{
char *str;
int i;
int nummodels, numsounds;
char mapname[MAX_QPATH];
int cs2;
qbool gpl_map;
#ifdef GLQUAKE
extern qbool r_gpl_map;
#endif
Com_DPrintf ("Serverdata packet received.\n");
//
// wipe the client_state_t struct
//
CL_ClearState ();
// parse protocol version number
i = MSG_ReadLong ();
if (i != NQ_PROTOCOL_VERSION)
Host_Error ("Server returned version %i, not %i", i, NQ_PROTOCOL_VERSION);
// parse maxclients
nq_maxclients = MSG_ReadByte ();
if (nq_maxclients < 1 || nq_maxclients > NQ_MAX_CLIENTS)
Host_Error ("Bad maxclients (%u) from server", nq_maxclients);
// parse gametype
cl.gametype = MSG_ReadByte() ? GAME_DEATHMATCH : GAME_COOP;
// parse signon message
str = MSG_ReadString ();
strlcpy (cl.levelname, str, sizeof(cl.levelname));
// separate the printfs so the server message can have a color
Com_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
Com_Printf ("%c%s\n", 2, str);
//
// first we go through and touch all of the precache data that still
// happens to be in the cache, so precaching something else doesn't
// needlessly purge it
//
// precache models
for (nummodels=1 ; ; nummodels++)
{
str = MSG_ReadString ();
if (!str[0])
break;
if (nummodels == MAX_MODELS)
Host_Error ("Server sent too many model precaches");
strlcpy (cl.model_name[nummodels], str, sizeof(cl.model_name[0]));
Mod_TouchModel (str);
}
// precache sounds
for (numsounds=1 ; ; numsounds++)
{
str = MSG_ReadString ();
if (!str[0])
break;
if (numsounds == MAX_SOUNDS)
Host_Error ("Server sent too many sound precaches");
strlcpy (cl.sound_name[numsounds], str, sizeof(cl.sound_name[0]));
S_TouchSound (str);
}
//
// now we try to load everything else until a cache allocation fails
//
cl.clipmodels[1] = CM_LoadMap (cl.model_name[1], true, NULL, &cl.map_checksum2);
COM_StripExtension (COM_SkipPath(cl.model_name[1]), mapname);
cs2 = Com_TranslateMapChecksum (mapname, cl.map_checksum2);
gpl_map = (cl.map_checksum2 != cs2);
cl.map_checksum2 = cs2;
#ifdef GLQUAKE
r_gpl_map = gpl_map;
#endif
for (i = 1; i < nummodels; i++)
{
cl.model_precache[i] = Mod_ForName (cl.model_name[i], false, i == 1);
if (cl.model_precache[i] == NULL)
Host_Error ("Model %s not found", cl.model_name[i]);
if (cl.model_name[i][0] == '*')
cl.clipmodels[i] = CM_InlineModel(cl.model_name[i]);
}
for (i=1 ; i<numsounds ; i++) {
cl.sound_precache[i] = S_PrecacheSound (cl.sound_name[i]);
}
// local state
if (!cl.model_precache[1])
Host_Error ("NQD_ParseServerData: NULL worldmodel");
COM_StripExtension (COM_SkipPath (cl.model_name[1]), mapname);
Cvar_ForceSet (&host_mapname, mapname);
CL_ClearParticles ();
CL_FindModelNumbers ();
R_NewMap (cl.model_precache[1]);
TP_NewMap ();
Hunk_Check (); // make sure nothing is hurt
nq_signon = 0;
nq_num_entities = 0;
nq_drawpings = false; // unless we have the ProQuake extension
cl.servertime_works = true;
cl.allow_fbskins = true;
r_refdef2.allow_cheats = true; // why not
cls.state = ca_onserver;
}
void CL_ParseServerInfo (void)
{
char *str;
int i;
int nummodels, numsounds;
char model_precache[MAX_MODELS][MAX_QPATH];
char sound_precache[MAX_SOUNDS][MAX_QPATH];
Con_DPrintf ("Serverinfo packet received.\n");
//
// wipe the client_state_t struct
//
CL_ClearState ();
// parse protocol version number
i = MSG_ReadLong ();
if (i != PROTOCOL_VERSION)
{
Con_Printf ("Server returned version %i, not %i", i, PROTOCOL_VERSION);
return;
}
// parse maxclients
cl.maxclients = MSG_ReadByte ();
if (cl.maxclients < 1 || cl.maxclients > MAX_SCOREBOARD)
{
Con_Printf("Bad maxclients (%u) from server\n", cl.maxclients);
return;
}
cl.scores = (scoreboard_t*) Hunk_AllocName (cl.maxclients*sizeof(*cl.scores), "scores");
// parse gametype
cl.gametype = MSG_ReadByte ();
// parse signon message
str = MSG_ReadString ();
strncpy (cl.levelname, str, sizeof(cl.levelname)-1);
// seperate the printfs so the server message can have a color
Con_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
Con_Printf ("%c%s\n", 2, str);
//
// first we go through and touch all of the precache data that still
// happens to be in the cache, so precaching something else doesn't
// needlessly purge it
//
// precache models
memset (cl.model_precache, 0, sizeof(cl.model_precache));
for (nummodels=1 ; ; nummodels++)
{
str = MSG_ReadString ();
if (!str[0])
break;
if (nummodels==MAX_MODELS)
{
Con_Printf ("Server sent too many model precaches\n");
return;
}
strcpy (model_precache[nummodels], str);
Mod_TouchModel (str);
}
// precache sounds
memset (cl.sound_precache, 0, sizeof(cl.sound_precache));
for (numsounds=1 ; ; numsounds++)
{
str = MSG_ReadString ();
if (!str[0])
break;
if (numsounds==MAX_SOUNDS)
{
Con_Printf ("Server sent too many sound precaches\n");
return;
}
strcpy (sound_precache[numsounds], str);
S_TouchSound (str);
}
//
// now we try to load everything else until a cache allocation fails
//
for (i=1 ; i<nummodels ; i++)
{
cl.model_precache[i] = Mod_ForName (model_precache[i], false);
if (cl.model_precache[i] == NULL)
{
Con_Printf("Model %s not found\n", model_precache[i]);
return;
}
CL_KeepaliveMessage ();
}
S_BeginPrecaching ();
for (i=1 ; i<numsounds ; i++)
{
cl.sound_precache[i] = S_PrecacheSound (sound_precache[i]);
CL_KeepaliveMessage ();
}
S_EndPrecaching ();
// local state
cl_entities[0].model = cl.worldmodel = cl.model_precache[1];
R_NewMap ();
Hunk_Check (); // make sure nothing is hurt
noclip_anglehack = false; // noclip is turned off at start
}
void S_Init (void)
{
if (snd_initialized) { //whoops
Com_Printf_State (PRINT_INFO, "Sound is already initialized\n");
return;
}
Com_DPrintf("\nSound Initialization\n");
Cvar_SetCurrentGroup(CVAR_GROUP_SOUND);
Cvar_Register(&bgmvolume);
Cvar_Register(&s_volume);
Cvar_Register(&s_nosound);
Cvar_Register(&s_precache);
Cvar_Register(&s_loadas8bit);
Cvar_Register(&s_khz);
Cvar_Register(&s_ambientlevel);
Cvar_Register(&s_ambientfade);
Cvar_Register(&s_noextraupdate);
Cvar_Register(&s_show);
Cvar_Register(&s_mixahead);
Cvar_Register(&s_swapstereo);
#if (defined(__linux__) || defined(__FreeBSD__))
Cvar_Register(&s_stereo);
Cvar_Register(&s_device);
Cvar_Register(&s_bits);
#endif
#ifdef __linux__
Cvar_Register(&s_noalsa);
#endif
Cvar_ResetCurrentGroup();
// compatibility with old configs
Cmd_AddLegacyCommand ("nosound", "s_nosound");
Cmd_AddLegacyCommand ("precache", "s_precache");
Cmd_AddLegacyCommand ("loadas8bit", "s_loadas8bit");
Cmd_AddLegacyCommand ("ambient_level", "s_ambientlevel");
Cmd_AddLegacyCommand ("ambient_fade", "s_ambientfade");
Cmd_AddLegacyCommand ("snd_noextraupdate", "s_noextraupdate");
Cmd_AddLegacyCommand ("snd_show", "s_show");
Cmd_AddLegacyCommand ("_snd_mixahead", "s_mixahead");
if (COM_CheckParm("-nosound")) {
Cmd_AddLegacyCommand ("play", ""); // just suppress warnings
return;
}
Cmd_AddCommand("snd_restart", S_Restart_f);
Cmd_AddLegacyCommand("s_restart", "snd_restart"); // exclusively for Disconnect
Cmd_AddCommand("play", S_Play_f);
Cmd_AddCommand("playvol", S_PlayVol_f);
Cmd_AddCommand("stopsound", S_StopAllSounds_f);
Cmd_AddCommand("soundlist", S_SoundList_f);
Cmd_AddCommand("soundinfo", S_SoundInfo_f);
if (!snd_initialized && host_memsize < 0x800000) {
Cvar_Set (&s_loadas8bit, "1");
Com_Printf ("loading all sounds as 8bit\n");
}
snd_initialized = true;
SND_InitScaletable ();
if (!S_Startup ()) {
snd_initialized = false;
return;
}
known_sfx = (sfx_t *) Hunk_AllocName (MAX_SFX * sizeof(sfx_t), "sfx_t");
num_sfx = 0;
ambient_sfx[AMBIENT_WATER] = S_PrecacheSound ("ambience/water1.wav");
ambient_sfx[AMBIENT_SKY] = S_PrecacheSound ("ambience/wind2.wav");
S_StopAllSounds (true);
}
void CDAudio_Play_byName (const char *trackname, qboolean looping, qboolean tryreal, float startposition)
{
unsigned int track;
sfx_t* sfx;
char filename[MAX_QPATH];
Host_StartVideo();
if (!enabled)
return;
if(tryreal && strspn(trackname, "0123456789") == strlen(trackname))
{
track = (unsigned char) atoi(trackname);
#ifdef MAXTRACKS
if(track > 0 && track < MAXTRACKS)
if(*remap[track])
{
if(strspn(remap[track], "0123456789") == strlen(remap[track]))
{
trackname = remap[track];
}
else
{
// ignore remappings to fake tracks if we're going to play a real track
switch(cdaudio.integer)
{
case 0: // we never access CD
case 1: // we have a replacement
trackname = remap[track];
break;
case 2: // we only use fake track replacement if CD track is invalid
CDAudio_GetAudioDiskInfo();
if(!cdValid || track > maxTrack)
trackname = remap[track];
break;
case 3: // we always play from CD - ignore this remapping then
case 4: // we randomize anyway
break;
}
}
}
#endif
}
if(tryreal && strspn(trackname, "0123456789") == strlen(trackname))
{
track = (unsigned char) atoi(trackname);
if (track < 1)
{
Con_DPrintf("CDAudio: Bad track number %u.\n", track);
return;
}
}
else
track = 0;
// div0: I assume this code was intentionally there. Maybe turn it into a cvar?
if (cdPlaying && cdPlayTrack == track && faketrack == -1)
return;
CDAudio_Stop ();
if(track >= 1)
{
if(cdaudio.integer == 3) // only play real CD tracks at all
{
if(CDAudio_Play_real(track, looping, true))
goto success;
return;
}
if(cdaudio.integer == 2) // prefer real CD track over fake
{
if(CDAudio_Play_real(track, looping, false))
goto success;
}
}
if(cdaudio.integer == 4) // only play real CD tracks, EVEN instead of fake tracks!
{
if(CDAudio_Play_real(track, looping, false))
goto success;
if(cdValid && maxTrack > 0)
{
track = 1 + (rand() % maxTrack);
if(CDAudio_Play_real(track, looping, true))
goto success;
}
else
{
Con_DPrint ("No CD in player.\n");
}
return;
}
// Try playing a fake track (sound file) first
if(track >= 1)
{
dpsnprintf(filename, sizeof(filename), "sound/cdtracks/track%03u.wav", track);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/track%03u.ogg", track);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/track%03u.ogg", track);// added by motorsep
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/cdtracks/track%03u.ogg", track);// added by motorsep
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/track%02u.wav", track);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/track%02u.ogg", track);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/track%02u.ogg", track);// added by motorsep
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/cdtracks/track%02u.ogg", track);// added by motorsep
}
else
{
dpsnprintf(filename, sizeof(filename), "%s", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "%s.wav", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "%s.ogg", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/%s", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/%s.wav", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/%s.ogg", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/%s", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/%s.wav", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "sound/cdtracks/%s.ogg", trackname);
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/%s.ogg", trackname); // added by motorsep
if (!FS_FileExists(filename)) dpsnprintf(filename, sizeof(filename), "music/cdtracks/%s.ogg", trackname); // added by motorsep
}
if (FS_FileExists(filename) && (sfx = S_PrecacheSound (filename, false, true)))
{
faketrack = S_StartSound_StartPosition (-1, 0, sfx, vec3_origin, cdvolume, 0, startposition);
if (faketrack != -1)
{
if (looping)
S_SetChannelFlag (faketrack, CHANNELFLAG_FORCELOOP, true);
S_SetChannelFlag (faketrack, CHANNELFLAG_FULLVOLUME, true);
S_SetChannelFlag (faketrack, CHANNELFLAG_LOCALSOUND, true); // not pausable
if(track >= 1)
{
if(cdaudio.integer != 0) // we don't need these messages if only fake tracks can be played anyway
Con_DPrintf ("Fake CD track %u playing...\n", track);
}
else
Con_DPrintf ("BGM track %s playing...\n", trackname);
}
}
// If we can't play a fake CD track, try the real one
if (faketrack == -1)
{
if(cdaudio.integer == 0 || track < 1)
{
Con_Print("Could not load BGM track.\n");
return;
}
else
{
if(!CDAudio_Play_real(track, looping, true))
return;
}
}
success:
cdPlayLooping = looping;
cdPlayTrack = track;
cdPlaying = true;
if (cdvolume == 0.0 || bgmvolume.value == 0)
CDAudio_Pause ();
}
