|
|
|
/*
|
|
|
|
sounds.c - sounds.lst parser
|
|
|
|
Copyright (C) 2024 Alibek Omarov
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
*/
|
|
|
|
#include "common.h"
|
|
|
|
|
|
|
|
enum soundlst_type_e
|
|
|
|
{
|
|
|
|
SoundList_None,
|
|
|
|
SoundList_Range,
|
|
|
|
SoundList_List
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char *soundlst_groups[SoundList_Groups] =
|
|
|
|
{
|
|
|
|
"BouncePlayerShell",
|
|
|
|
"BounceWeaponShell",
|
|
|
|
"BounceConcrete",
|
|
|
|
"BounceGlass",
|
|
|
|
"BounceMetal",
|
|
|
|
"BounceFlesh",
|
|
|
|
"BounceWood",
|
|
|
|
"Ricochet",
|
|
|
|
"Explode",
|
|
|
|
"PlayerWaterEnter",
|
|
|
|
"PlayerWaterExit",
|
|
|
|
"EntityWaterEnter",
|
|
|
|
"EntityWaterExit",
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct soundlst_s
|
|
|
|
{
|
|
|
|
enum soundlst_type_e type;
|
|
|
|
char *snd;
|
|
|
|
int min; // the string length if type is group
|
|
|
|
int max; // the string count if type is group
|
|
|
|
} soundlst_t;
|
|
|
|
|
|
|
|
soundlst_t soundlst[SoundList_Groups];
|
|
|
|
|
|
|
|
static void SoundList_Print_f( void );
|
|
|
|
static void SoundList_Free( soundlst_t *lst )
|
|
|
|
{
|
|
|
|
if( lst->snd )
|
|
|
|
Mem_Free( lst->snd );
|
|
|
|
|
|
|
|
memset( lst, 0, sizeof( *lst ));
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundList_Shutdown( void )
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for( i = 0; i < SoundList_Groups; i++ )
|
|
|
|
SoundList_Free( &soundlst[i] );
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundList_Count( enum soundlst_group_e group )
|
|
|
|
{
|
|
|
|
soundlst_t *lst = &soundlst[group];
|
|
|
|
|
|
|
|
switch( lst->type )
|
|
|
|
{
|
|
|
|
case SoundList_Range:
|
|
|
|
return lst->max - lst->min + 1;
|
|
|
|
case SoundList_List:
|
|
|
|
return lst->max;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *SoundList_Get( enum soundlst_group_e group, int i )
|
|
|
|
{
|
|
|
|
static string temp;
|
|
|
|
soundlst_t *lst = &soundlst[group];
|
|
|
|
|
|
|
|
if( i < 0 || i >= SoundList_Count( group ))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
switch( lst->type )
|
|
|
|
{
|
|
|
|
case SoundList_Range:
|
|
|
|
Q_snprintf( temp, sizeof( temp ), lst->snd, lst->min + i );
|
|
|
|
return temp;
|
|
|
|
case SoundList_List:
|
|
|
|
return &lst->snd[i * lst->min];
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *SoundList_GetRandom( enum soundlst_group_e group )
|
|
|
|
{
|
|
|
|
int count = SoundList_Count( group );
|
|
|
|
int idx = COM_RandomLong( 0, count - 1 );
|
|
|
|
|
|
|
|
// Con_Printf( "%s: %s %d %d\n", __func__, soundlst_groups[group], count, idx );
|
|
|
|
|
|
|
|
return SoundList_Get( group, idx );
|
|
|
|
}
|
|
|
|
|
|
|
|
static qboolean SoundList_ParseGroup( soundlst_t *lst, char **file )
|
|
|
|
{
|
|
|
|
string token;
|
|
|
|
int count = 0, slen = 0, i;
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
p = *file;
|
|
|
|
|
|
|
|
while(( p = COM_ParseFile( p, token, sizeof( token ))))
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if( !Q_strcmp( token, "}" ))
|
|
|
|
break;
|
|
|
|
|
|
|
|
if( !Q_strcmp( token, "{" ))
|
|
|
|
{
|
|
|
|
Con_Printf( "%s: expected '}' but got '{' during group list parse\n", __func__ );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else if( !COM_CheckStringEmpty( token ))
|
|
|
|
{
|
|
|
|
Con_Printf( "%s: expected '}' but got EOF during group list parse\n", __func__ );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
len = Q_strlen( token ) + 1;
|
|
|
|
if( slen < len )
|
|
|
|
slen = len;
|
|
|
|
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( count == 0 ) // deactivate group
|
|
|
|
{
|
|
|
|
lst->type = SoundList_None;
|
|
|
|
lst->snd = NULL;
|
|
|
|
lst->min = lst->max = 0;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
lst->type = SoundList_List;
|
|
|
|
lst->min = slen;
|
|
|
|
lst->max = count;
|
|
|
|
lst->snd = Mem_Malloc( host.mempool, count * slen ); // allocate single buffer for the whole group
|
|
|
|
|
|
|
|
for( i = 0; i < count; i++ )
|
|
|
|
{
|
|
|
|
*file = COM_ParseFile( *file, token, sizeof( token ));
|
|
|
|
|
|
|
|
Q_strncpy( &lst->snd[i * slen], token, slen );
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static qboolean SoundList_ParseRange( soundlst_t *lst, char **file )
|
|
|
|
{
|
|
|
|
string token, snd;
|
|
|
|
char *p;
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
lst->type = SoundList_Range;
|
|
|
|
*file = COM_ParseFile( *file, snd, sizeof( snd ));
|
|
|
|
|
|
|
|
// validate format string, count all % characters
|
|
|
|
p = snd;
|
|
|
|
i = 0;
|
|
|
|
while(( p = Q_strchr( p, '%' )))
|
|
|
|
{
|
|
|
|
// only decimal
|
|
|
|
if( p[1] != 'd' && p[1] != 'i' && p[1] != 'u' )
|
|
|
|
{
|
|
|
|
Con_Printf( "%s: invalid range string %s, only decimal numbers are allowed", __func__, snd );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
i++;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if more than one %, then it's an invalid format string
|
|
|
|
if( i != 1 )
|
|
|
|
{
|
|
|
|
Con_Printf( "%s: invalid range string %s, only single specifier is allowed\n", __func__, snd );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*file = COM_ParseFile( *file, token, sizeof( token ));
|
|
|
|
if( !Q_isdigit( token ))
|
|
|
|
{
|
|
|
|
Con_Printf( "%s: %s must be a digit\n", __func__, token );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
lst->min = Q_atoi( token );
|
|
|
|
|
|
|
|
*file = COM_ParseFile( *file, token, sizeof( token ));
|
|
|
|
if( !Q_isdigit( token ))
|
|
|
|
{
|
|
|
|
Con_Printf( "%s: %s must be a digit\n", __func__, token );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
lst->max = Q_atoi( token );
|
|
|
|
lst->snd = copystring( snd );
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static qboolean SoundList_Parse( char *file )
|
|
|
|
{
|
|
|
|
string token;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
while(( file = COM_ParseFile( file, token, sizeof( token ))))
|
|
|
|
{
|
|
|
|
soundlst_t *lst = NULL;
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
for( i = 0; i < SoundList_Groups; i++ )
|
|
|
|
{
|
|
|
|
if( !Q_strcmp( token, soundlst_groups[i] ))
|
|
|
|
{
|
|
|
|
lst = &soundlst[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( !lst )
|
|
|
|
{
|
|
|
|
Con_Printf( "%s: unexpected token %s, must be group name\n", __func__, token );
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = COM_ParseFile( file, token, sizeof( token ));
|
|
|
|
|
|
|
|
// group is a range
|
|
|
|
if( !Q_strcmp( token, "{" ))
|
|
|
|
{
|
|
|
|
file = p; // advance pointer
|
|
|
|
|
|
|
|
if( !SoundList_ParseGroup( lst, &file ))
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
file = COM_ParseFile( file, token, sizeof( token ));
|
|
|
|
if( Q_strcmp( token, "}" ))
|
|
|
|
{
|
|
|
|
Con_Printf( "%s: unexpected token %s, must be }\n", __func__, token );
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// ranges are more simple, but need to rewind pointer for them
|
|
|
|
if( !SoundList_ParseRange( lst, &file ))
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( host_developer.value >= 2 )
|
|
|
|
SoundList_Print_f();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
SoundList_Shutdown();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void SoundList_Print_f( void )
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for( i = 0; i < SoundList_Groups; i++ )
|
|
|
|
{
|
|
|
|
soundlst_t *lst = &soundlst[i];
|
|
|
|
|
|
|
|
switch( lst->type )
|
|
|
|
{
|
|
|
|
case SoundList_Range:
|
|
|
|
Con_Reportf( "%-16s\t" S_CYAN "Range" S_DEFAULT " %s [%d; %d]\n",
|
|
|
|
soundlst_groups[i], lst->snd, lst->min, lst->max );
|
|
|
|
break;
|
|
|
|
case SoundList_List:
|
|
|
|
{
|
|
|
|
int j;
|
|
|
|
|
|
|
|
Con_Reportf( "%-16s\t" S_MAGENTA "List" S_DEFAULT " [", soundlst_groups[i] );
|
|
|
|
for( j = 0; j < lst->max; j++ )
|
|
|
|
Con_Reportf( "%s%s", &lst->snd[j * lst->min], j + 1 == lst->max ? "" : ", " );
|
|
|
|
Con_Reportf( "]\n" );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
Con_Reportf( "%-16s\t" S_RED "inactive" S_DEFAULT "\n", soundlst_groups[i] );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// I wish we had #embed already
|
|
|
|
static const char default_sounds_lst[] =
|
|
|
|
"BouncePlayerShell \"player/pl_shell%d.wav\" 1 3\n"
|
|
|
|
"BounceWeaponShell \"weapons/sshell%d.wav\" 1 3\n"
|
|
|
|
"BounceConcrete \"debris/concrete%d.wav\" 1 3\n"
|
|
|
|
"BounceGlass \"debris/glass%d.wav\" 1 4\n"
|
|
|
|
"BounceMetal \"debris/metal%d.wav\" 1 6\n"
|
|
|
|
"BounceFlesh \"debris/flesh%d.wav\" 1 7\n"
|
|
|
|
"BounceWood \"debris/wood%d.wav\" 1 4\n"
|
|
|
|
"Ricochet \"weapons/ric%d.wav\" 1 5\n"
|
|
|
|
"Explode \"weapons/explode%d.wav\" 3 5\n"
|
|
|
|
"EntityWaterEnter \"player/pl_wade%d.wav\" 1 4\n"
|
|
|
|
"EntityWaterExit \"player/pl_wade%d.wav\" 1 4\n"
|
|
|
|
"PlayerWaterEnter\n"
|
|
|
|
"{\n"
|
|
|
|
" \"player/pl_wade1.wav\"\n"
|
|
|
|
"}\n"
|
|
|
|
"\n"
|
|
|
|
"PlayerWaterExit\n"
|
|
|
|
"{\n"
|
|
|
|
" \"player/pl_wade2.wav\"\n"
|
|
|
|
"}\n";
|
|
|
|
|
|
|
|
static void SoundList_Reload_f( void )
|
|
|
|
{
|
|
|
|
qboolean load_internal = false;
|
|
|
|
char *pfile = FS_LoadFile( "scripts/sounds.lst", NULL, false );
|
|
|
|
|
|
|
|
if( pfile )
|
|
|
|
{
|
|
|
|
if( !SoundList_Parse( pfile ))
|
|
|
|
{
|
|
|
|
Con_Printf( S_ERROR "can't parse sounds.lst file, loading internal...\n" );
|
|
|
|
load_internal = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
Mem_Free( pfile );
|
|
|
|
}
|
|
|
|
else load_internal = true;
|
|
|
|
|
|
|
|
if( load_internal )
|
|
|
|
SoundList_Parse( (char *)default_sounds_lst );
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundList_Init( void )
|
|
|
|
{
|
|
|
|
Cmd_AddRestrictedCommand( "host_soundlist_print", SoundList_Print_f, "print current sound list" );
|
|
|
|
Cmd_AddRestrictedCommand( "host_soundlist_reload", SoundList_Reload_f, "reload sound list" );
|
|
|
|
|
|
|
|
SoundList_Reload_f ();
|
|
|
|
}
|