int engine_config_write_start()
{
config_save("settings.cfg");
config_file = engine_openfile("settings.cfg", IOFLAG_WRITE);
config_file = engine_openfile("settings.txt", IOFLAG_WRITE);
if(config_file == 0)
return -1;
return 0;
}
static void console_execute_file_real(const char *filename)
{
IOHANDLE file;
file = engine_openfile(filename, IOFLAG_READ);
if(file)
{
//VOTEOPTION *current = voteoption_first;
//while(current)
//{
// current = current->next;
// current->prev=0;
//}
//int i=0;
//for(i;i<MAX_CLIENTS;i++)
// if (game.players[i]->authed==0)
// server_kick(i, "Server settings reload");
char *line;
LINEREADER lr;
dbg_msg("console", "executing '%s'", filename);
linereader_init(&lr, file);
while((line = linereader_get(&lr)))
console_execute_line(line,-1);
io_close(file);
}
else
dbg_msg("console", "failed to open '%s'", filename);
}
int font_load(FONT *font, const char *filename)
{
FONT_DATA font_data;
IOHANDLE file;
file = engine_openfile(filename, IOFLAG_READ);
if(file)
{
int i;
io_read(file, &font_data, sizeof(FONT_DATA));
io_close(file);
#if defined(CONF_ARCH_ENDIAN_BIG)
swap_endian(&font_data, 2, sizeof(FONT_DATA)/2);
#endif
{
float scale_factor_x = 1.0f/font_data.size;
float scale_factor_y = 1.0f/font_data.size;
float scale_factor_tex_x = 1.0f/font_data.width;
float scale_factor_tex_y = 1.0f/font_data.height;
for (i = 0; i < 256; i++)
{
float tex_x0 = font_data.characters[i].x*scale_factor_tex_x;
float tex_y0 = font_data.characters[i].y*scale_factor_tex_y;
float tex_x1 = (font_data.characters[i].x+font_data.characters[i].width)*scale_factor_tex_x;
float tex_y1 = (font_data.characters[i].y+font_data.characters[i].height)*scale_factor_tex_y;
float width = font_data.characters[i].width*scale_factor_x;
float height = font_data.characters[i].height*scale_factor_y;
float x_offset = font_data.characters[i].x_offset*scale_factor_x;
float y_offset = font_data.characters[i].y_offset*scale_factor_y;
float x_advance = (font_data.characters[i].x_advance)*scale_factor_x;
font->characters[i].tex_x0 = tex_x0;
font->characters[i].tex_y0 = tex_y0;
font->characters[i].tex_x1 = tex_x1;
font->characters[i].tex_y1 = tex_y1;
font->characters[i].width = width;
font->characters[i].height = height;
font->characters[i].x_offset = x_offset;
font->characters[i].y_offset = y_offset;
font->characters[i].x_advance = x_advance;
}
for (i = 0; i < 256*256; i++)
{
font->kerning[i] = (char)font_data.kerning[i];
}
}
return 0;
}
else
return -1;
}
int mastersrv_load()
{
LINEREADER lr;
IOHANDLE file;
int count = 0;
/* try to open file */
file = engine_openfile("masters.cfg", IOFLAG_READ);
if(!file)
return -1;
linereader_init(&lr, file);
while(1)
{
MASTER_INFO info = {{0}};
int ip[4];
const char *line = linereader_get(&lr);
if(!line)
break;
/* parse line */
if(sscanf(line, "%s %d.%d.%d.%d", info.hostname, &ip[0], &ip[1], &ip[2], &ip[3]) == 5)
{
info.addr.ip[0] = (unsigned char)ip[0];
info.addr.ip[1] = (unsigned char)ip[1];
info.addr.ip[2] = (unsigned char)ip[2];
info.addr.ip[3] = (unsigned char)ip[3];
info.addr.port = 8300;
if(count != MAX_MASTERSERVERS)
{
master_servers[count] = info;
count++;
}
else
dbg_msg("engine/mastersrv", "warning: skipped master server '%s' due to limit of %d", line, MAX_MASTERSERVERS);
}
else
dbg_msg("engine/mastersrv", "warning: couldn't parse master server '%s'", line);
}
io_close(file);
return 0;
}
static void console_execute_file_real(const char *filename)
{
IOHANDLE file;
file = engine_openfile(filename, IOFLAG_READ);
if(file)
{
char *line;
LINEREADER lr;
dbg_msg("console", "executing '%s'", filename);
linereader_init(&lr, file);
while((line = linereader_get(&lr)))
console_execute_line(line);
io_close(file);
}
else
dbg_msg("console", "failed to open '%s'", filename);
}
int datafile_crc(const char *filename)
{
unsigned char buffer[BUFFER_SIZE];
IOHANDLE file;
int crc = 0;
unsigned bytes = 0;
file = engine_openfile(filename, IOFLAG_READ);
if(!file)
return 0;
while(1)
{
bytes = io_read(file, buffer, BUFFER_SIZE);
if(bytes <= 0)
break;
crc = crc32(crc, buffer, bytes);
}
io_close(file);
return crc;
}
int mastersrv_save()
{
IOHANDLE file;
int i;
/* try to open file */
file = engine_openfile("masters.cfg", IOFLAG_WRITE);
if(!file)
return -1;
for(i = 0; i < MAX_MASTERSERVERS; i++)
{
char buf[1024];
str_format(buf, sizeof(buf), "%s %d.%d.%d.%d\n", master_servers[i].hostname,
master_servers[i].addr.ip[0], master_servers[i].addr.ip[1],
master_servers[i].addr.ip[2], master_servers[i].addr.ip[3]);
io_write(file, buf, strlen(buf));
}
io_close(file);
return 0;
}
DATAFILE_OUT *datafile_create(const char *filename)
{
int i;
DATAFILE_OUT *df = (DATAFILE_OUT*)mem_alloc(sizeof(DATAFILE_OUT), 1);
df->file = engine_openfile(filename, IOFLAG_WRITE);
if(!df->file)
{
mem_free(df);
return 0;
}
df->num_items = 0;
df->num_datas = 0;
df->num_item_types = 0;
mem_zero(&df->item_types, sizeof(df->item_types));
for(i = 0; i < 0xffff; i++)
{
df->item_types[i].first = -1;
df->item_types[i].last = -1;
}
return df;
}
DATAFILE *datafile_load(const char *filename)
{
DATAFILE *df;
IOHANDLE file;
DATAFILE_HEADER header;
unsigned readsize;
unsigned *dst;
unsigned char *src;
unsigned j;
int size = 0;
int allocsize = 0;
(void)dst;
(void)src;
(void)j;
dbg_msg("datafile", "datafile loading. filename='%s'", filename);
file = engine_openfile(filename, IOFLAG_READ);
if(!file)
return 0;
/* TODO: change this header */
io_read(file, &header, sizeof(header));
if(header.id[0] != 'A' || header.id[1] != 'T' || header.id[2] != 'A' || header.id[3] != 'D')
{
if(header.id[0] != 'D' || header.id[1] != 'A' || header.id[2] != 'T' || header.id[3] != 'A')
{
dbg_msg("datafile", "wrong signature. %x %x %x %x", header.id[0], header.id[1], header.id[2], header.id[3]);
return 0;
}
}
#if defined(CONF_ARCH_ENDIAN_BIG)
swap_endian(&header, sizeof(int), sizeof(header)/sizeof(int));
#endif
if(header.version != 3 && header.version != 4)
{
dbg_msg("datafile", "wrong version. version=%x", header.version);
return 0;
}
/* read in the rest except the data */
size = 0;
size += header.num_item_types*sizeof(DATAFILE_ITEM_TYPE);
size += (header.num_items+header.num_raw_data)*sizeof(int);
if(header.version == 4)
size += header.num_raw_data*sizeof(int); /* v4 has uncompressed data sizes aswell */
size += header.item_size;
allocsize = size;
allocsize += sizeof(DATAFILE); /* add space for info structure */
allocsize += header.num_raw_data*sizeof(void*); /* add space for data pointers */
df = (DATAFILE*)mem_alloc(allocsize, 1);
df->header = header;
df->data_start_offset = sizeof(DATAFILE_HEADER) + size;
df->data_ptrs = (char**)(df+1);
df->data = (char *)(df+1)+header.num_raw_data*sizeof(char *);
df->file = file;
/* clear the data pointers */
mem_zero(df->data_ptrs, header.num_raw_data*sizeof(void*));
/* read types, offsets, sizes and item data */
readsize = io_read(file, df->data, size);
if(readsize != size)
{
dbg_msg("datafile", "couldn't load the whole thing, wanted=%d got=%d", size, readsize);
return 0;
}
#if defined(CONF_ARCH_ENDIAN_BIG)
swap_endian(df->data, sizeof(int), header.swaplen / sizeof(int));
#endif
if(DEBUG)
{
dbg_msg("datafile", "allocsize=%d", allocsize);
dbg_msg("datafile", "readsize=%d", readsize);
dbg_msg("datafile", "swaplen=%d", header.swaplen);
dbg_msg("datafile", "item_size=%d", df->header.item_size);
}
df->info.item_types = (DATAFILE_ITEM_TYPE *)df->data;
df->info.item_offsets = (int *)&df->info.item_types[df->header.num_item_types];
df->info.data_offsets = (int *)&df->info.item_offsets[df->header.num_items];
df->info.data_sizes = (int *)&df->info.data_offsets[df->header.num_raw_data];
if(header.version == 4)
df->info.item_start = (char *)&df->info.data_sizes[df->header.num_raw_data];
else
df->info.item_start = (char *)&df->info.data_offsets[df->header.num_raw_data];
df->info.data_start = df->info.item_start + df->header.item_size;
if(DEBUG)
dbg_msg("datafile", "datafile loading done. datafile='%s'", filename);
if(DEBUG)
{
/*
for(int i = 0; i < df->data.num_raw_data; i++)
{
void *p = datafile_get_data(df, i);
dbg_msg("datafile", "%d %d", (int)((char*)p - (char*)(&df->data)), size);
}
for(int i = 0; i < datafile_num_items(df); i++)
{
int type, id;
void *data = datafile_get_item(df, i, &type, &id);
dbg_msg("map", "\t%d: type=%x id=%x p=%p offset=%d", i, type, id, data, df->info.item_offsets[i]);
int *idata = (int*)data;
for(int k = 0; k < 3; k++)
dbg_msg("datafile", "\t\t%d=%d (%x)", k, idata[k], idata[k]);
}
for(int i = 0; i < df->data.num_item_types; i++)
{
dbg_msg("map", "\t%d: type=%x start=%d num=%d", i,
df->info.item_types[i].type,
df->info.item_types[i].start,
df->info.item_types[i].num);
for(int k = 0; k < df->info.item_types[i].num; k++)
{
int type, id;
datafile_get_item(df, df->info.item_types[i].start+k, &type, &id);
if(type != df->info.item_types[i].type)
dbg_msg("map", "\tERROR");
}
}
*/
}
return df;
}
int snd_load_wv(const char *filename)
{
SAMPLE *snd;
int sid = -1;
char error[100];
WavpackContext *context;
/* don't waste memory on sound when we are stress testing */
if(config.dbg_stress)
return -1;
/* no need to load sound when we are running with no sound */
if(!sound_enabled)
return 1;
file = engine_openfile(filename, IOFLAG_READ); /* TODO: use system.h stuff for this */
if(!file)
{
dbg_msg("sound/wv", "failed to open %s", filename);
return -1;
}
sid = snd_alloc_id();
if(sid < 0)
return -1;
snd = &samples[sid];
context = WavpackOpenFileInput(read_data, error);
if (context)
{
int samples = WavpackGetNumSamples(context);
int bitspersample = WavpackGetBitsPerSample(context);
unsigned int samplerate = WavpackGetSampleRate(context);
int channels = WavpackGetNumChannels(context);
int *data;
int *src;
short *dst;
int i;
snd->channels = channels;
snd->rate = samplerate;
if(snd->channels > 2)
{
dbg_msg("sound/wv", "file is not mono or stereo. filename='%s'", filename);
return -1;
}
/*
if(snd->rate != 44100)
{
dbg_msg("sound/wv", "file is %d Hz, not 44100 Hz. filename='%s'", snd->rate, filename);
return -1;
}*/
if(bitspersample != 16)
{
dbg_msg("sound/wv", "bps is %d, not 16, filname='%s'", bitspersample, filename);
return -1;
}
data = (int *)mem_alloc(4*samples*channels, 1);
WavpackUnpackSamples(context, data, samples); /* TODO: check return value */
src = data;
snd->data = (short *)mem_alloc(2*samples*channels, 1);
dst = snd->data;
for (i = 0; i < samples*channels; i++)
*dst++ = (short)*src++;
mem_free(data);
snd->num_frames = samples;
snd->loop_start = -1;
snd->loop_end = -1;
}
else
{
dbg_msg("sound/wv", "failed to open %s: %s", filename, error);
}
io_close(file);
file = NULL;
if(config.debug)
dbg_msg("sound/wv", "loaded %s", filename);
rate_convert(sid);
return sid;
}
