static void WriteCache( void ) { char buffer[MAX_OSPATH]; qhandle_t f; int i; char *map, *pov; demoEntry_t *e; size_t len; if( m_demos.list.numItems == m_demos.numDirs ) { return; } len = Q_concat( buffer, sizeof( buffer ), m_demos.browse, "/" COM_DEMOCACHE_NAME, NULL ); if( len >= sizeof( buffer ) ) { return; } FS_FOpenFile( buffer, &f, FS_MODE_WRITE ); if( !f ) { return; } for( i = 0; i < 16; i++ ) { FS_FPrintf( f, "%02x", m_demos.hash[i] ); } FS_FPrintf( f, "\\" ); for( i = m_demos.numDirs; i < m_demos.list.numItems; i++ ) { e = m_demos.list.items[i]; map = UI_GetColumn( e->name, COL_MAP ); pov = UI_GetColumn( e->name, COL_POV ); FS_FPrintf( f, "%s\\%s\\", map, pov ); } FS_FCloseFile( f ); }
/* static qboolean SV_RunGameFrame( int msec ) { int extraTime = 0; static unsigned int accTime = 0; accTime += msec; // move autonomous things around if enough time has passed if( svs.gametime < sv.nextSnapTime ) { if( svs.gametime + svc.snapFrameTime < sv.nextSnapTime ) { if( sv_showclamp->integer ) Com_Printf( "sv lowclamp\n" ); sv.nextSnapTime = svs.gametime + svc.snapFrameTime; return qfalse; } // see if it's time to advance the world if( accTime >= WORLDFRAMETIME ) { if( host_speeds->integer ) time_before_game = Sys_Milliseconds(); ge->RunFrame( WORLDFRAMETIME, svs.gametime ); if( host_speeds->integer ) time_after_game = Sys_Milliseconds(); accTime = accTime - WORLDFRAMETIME; } if( !SV_SendClientsFragments() ) { // FIXME: gametime might slower/faster than real time if( dedicated->integer ) { socket_t *sockets[] = { &svs.socket_udp, NULL }; NET_Sleep( min( WORLDFRAMETIME - accTime, sv.nextSnapTime - svs.gametime ), sockets ); } } return qfalse; } if( sv.nextSnapTime <= svs.gametime ) { extraTime = (int)( svs.gametime - sv.nextSnapTime ); } if( extraTime >= msec ) extraTime = msec - 1; sv.nextSnapTime = ( svs.gametime + svc.snapFrameTime ) - extraTime; // Execute all clients pending move commands if( accTime ) { ge->RunFrame( accTime, svs.gametime ); accTime = 0; } // update ping based on the last known frame from all clients SV_CalcPings(); sv.framenum++; ge->SnapFrame(); return qtrue; } */ static void SV_CheckDefaultMap( void ) { if( svc.autostarted ) return; svc.autostarted = qtrue; if( dedicated->integer ) { if( sv.state == ss_dead && !strlen( sv.mapname ) ) { int filehandle; if( sv_write_defaultmap && sv_write_defaultmap->integer && FS_FOpenFile( "defaultmap", &filehandle, FS_READ ) != -1 ) { static char buffer[MAX_QPATH]; buffer[0] = '\0'; FS_Read( buffer, MAX_QPATH - 1, filehandle ); FS_FCloseFile( filehandle ); if( buffer[0] ) { Cbuf_ExecuteText( EXEC_APPEND, va( "map %s\n", buffer ) ); return; } } if( sv_defaultmap && strlen( sv_defaultmap->string ) ) Cbuf_ExecuteText( EXEC_APPEND, va( "map %s\n", sv_defaultmap->string ) ); } } }
// returns static string of md5 contents const char *MM_PasswordRead( const char *user ) { static char buffer[MAX_STRING_CHARS]; const char *filename; int filenum; size_t bytes; Com_DPrintf( "MM_PasswordRead %s\n", user ); filename = mm_passwordFilename( user ); if( FS_FOpenFile( filename, &filenum, FS_READ ) == -1 ) { Com_Printf( "MM_PasswordRead: Couldnt open file %s\n", filename); return NULL; } bytes = FS_Read(buffer, sizeof( buffer ) - 1, filenum ); FS_FCloseFile( filenum ); if( bytes == 0 || bytes >= sizeof(buffer) - 1 ) return NULL; buffer[bytes] = '\0'; return buffer; }
/* * CL_CheckOrDownloadFile * * Returns true if the file exists or couldn't send download request * Files with .pk3 or .pak extension have to have gamedir attached * Other files must not have gamedir */ qboolean CL_CheckOrDownloadFile( const char *filename ) { const char *ext; if( !cl_downloads->integer ) return qtrue; if( !COM_ValidateRelativeFilename( filename ) ) return qtrue; ext = COM_FileExtension( filename ); if( !ext || !*ext ) return qtrue; if( FS_CheckPakExtension( filename ) ) { if( FS_FOpenBaseFile( filename, NULL, FS_READ ) != -1 ) return qtrue; } else { if( FS_FOpenFile( filename, NULL, FS_READ ) != -1 ) return qtrue; } if( !CL_DownloadRequest( filename, qtrue ) ) return qtrue; cls.download.requestnext = qtrue; // call CL_RequestNextDownload when done return qfalse; }
static size_t wswcurl_write(void *ptr, size_t size, size_t nmemb, void *stream) { wswcurl_req *req = (wswcurl_req*)stream; if (!req->filename) { // Reallocate buffer req->rxdata = WREALLOC(req->rxdata, req->rxsize + (size * nmemb) + 1); // Set remaining data to 0 memset(&(req->rxdata[req->rxsize]), 0, (size * nmemb)); // Copy received data memcpy(&(req->rxdata[req->rxsize]), ptr, size*nmemb); // Recalculate size req->rxsize += size*nmemb; // Add trailing NULL byte at the end to prevent string overflow req->rxdata[req->rxsize] = '\0'; } else { // Receive to the filename. // TODO: FILE RESUMING?? #ifndef WSWCURL_TEST_MAIN if ( (req->filenum < 0) && ( FS_FOpenFile( req->filename, &(req->filenum), FS_WRITE ) < 0 ) ) { return 0; // RETURN ERROR } FS_Write(ptr, size * nmemb, req->filenum); #else // TODO: IMPLEMENT TEST #endif } // Mark connection as having had activity. req->activity = 1; if (req->callback_progress) { // Execute progress callback // ??? What to return when expected size is unknown? - currently, return 0.0 req->callback_progress(req, ( req->rx_expsize < 0 ) ? 0.0 : (req->rxsize / req->rx_expsize) * 100.0); } return size*nmemb; }
/* * Filename are reletive to the quake search path. A null buffer will just * return the file length without loading. */ int FS_LoadFile(char *path, void **buffer) { byte *buf; /* Buffer. */ int size; /* File size. */ fileHandle_t f; /* File handle. */ buf = NULL; size = FS_FOpenFile(path, &f, FS_READ); if (size <= 0) { if (buffer) { *buffer = NULL; } return size; } if (buffer == NULL) { FS_FCloseFile(f); return size; } buf = Z_Malloc(size); *buffer = buf; FS_Read(buf, size, f); FS_FCloseFile(f); return size; }
void SV_ReadLevelFile(void) { char name[MAX_OSPATH]; fileHandle_t f; Com_DPrintf("SV_ReadLevelFile()\n"); Com_sprintf(name, sizeof(name), "save/current/%s.sv2", sv.name); FS_FOpenFile(name, &f, FS_READ); if (!f) { Com_Printf("Failed to open %s\n", name); return; } FS_Read(sv.configstrings, sizeof(sv.configstrings), f); CM_ReadPortalState(f); FS_FCloseFile(f); Com_sprintf(name, sizeof(name), "%s/save/current/%s.sav", FS_Gamedir(), sv.name); ge->ReadLevel(name); }
/* ============ FS_LoadFile Filename are reletive to the quake search path a null buffer will just return the file length without loading ============ */ int FS_LoadFile(char *path, void **buffer) { FILE *h; byte *buf; int len; buf = NULL; // quiet compiler warning // look for it in the filesystem or pack files len = FS_FOpenFile(path, &h); if (!h) { if (buffer) *buffer = NULL; return -1; } if (!buffer) { fclose(h); return len; } buf = Z_Malloc(len); *buffer = buf; FS_Read(buf, len, h); fclose(h); return len; }
void Prompt_LoadHistory( commandPrompt_t *prompt, const char *filename ) { char buffer[MAX_FIELD_TEXT]; qhandle_t f; int i; ssize_t len; FS_FOpenFile( filename, &f, FS_MODE_READ|FS_TYPE_REAL|FS_PATH_BASE ); if( !f ) { return; } for( i = 0; i < HISTORY_SIZE; i++ ) { if( ( len = FS_ReadLine( f, buffer, sizeof( buffer ) ) ) < 1 ) { break; } if( prompt->history[i] ) { Z_Free( prompt->history[i] ); } prompt->history[i] = memcpy( Z_Malloc( len + 1 ), buffer, len + 1 ); } FS_FCloseFile( f ); prompt->historyLineNum = i; prompt->inputLineNum = i; }
void Prompt_SaveHistory( commandPrompt_t *prompt, const char *filename, int lines ) { qhandle_t f; char *s; int i; FS_FOpenFile( filename, &f, FS_MODE_WRITE|FS_PATH_BASE ); if( !f ) { return; } if( lines > HISTORY_SIZE ) { lines = HISTORY_SIZE; } i = prompt->inputLineNum - lines; if( i < 0 ) { i = 0; } for( ; i < prompt->inputLineNum; i++ ) { s = prompt->history[i & HISTORY_MASK]; if( s ) { FS_FPrintf( f, "%s\n", s ); } } FS_FCloseFile( f ); }
static int read_binary_file(const char *name) { qhandle_t f; size_t len; len = FS_FOpenFile(name, &f, FS_MODE_READ | FS_TYPE_REAL | FS_PATH_GAME); if (!f) return -1; if (len > MAX_MSGLEN) goto fail; if (FS_Read(msg_read_buffer, len, f) != len) goto fail; SZ_Init(&msg_read, msg_read_buffer, len); msg_read.cursize = len; FS_FCloseFile(f); return 0; fail: FS_FCloseFile(f); return -1; }
/* * SNAP_WriteDemoMetaData */ void SNAP_WriteDemoMetaData( const char *filename, const char *meta_data, size_t meta_data_realsize ) { unsigned i; unsigned v; char tmpn[256]; int filenum, filelen; msg_t msg; uint8_t msg_buffer[MAX_MSGLEN]; void *compressed_msg; MSG_Init( &msg, msg_buffer, sizeof( msg_buffer ) ); // write to a temp file v = 0; for( i = 0; filename[i]; i++ ) { v = ( v + i ) * 37 + tolower( filename[i] ); // case insensitivity } Q_snprintfz( tmpn, sizeof( tmpn ), "%u.tmp", v ); if( FS_FOpenFile( tmpn, &filenum, FS_WRITE|SNAP_DEMO_GZ ) == -1 ) { return; } SNAP_DemoMetaDataMessage( &msg, meta_data, meta_data_realsize ); SNAP_RecordDemoMetaDataMessage( filenum, &msg ); // now open the original file in update mode and overwrite metadata // important note: we need to the load the temp file before closing it // because in the case of gz compression, closing the file may actually // write some data we don't want to copy filelen = FS_LoadFile( tmpn, &compressed_msg, NULL, 0 ); if( compressed_msg ) { int origfile; if( FS_FOpenFile( filename, &origfile, FS_READ|FS_UPDATE ) != -1 ) { FS_Write( compressed_msg, filelen, origfile ); FS_FCloseFile( origfile ); } FS_FreeFile( compressed_msg ); } FS_FCloseFile( filenum ); FS_RemoveFile( tmpn ); }
/* * CL_ReadServerCache */ void CL_ReadServerCache( void ) { int filelen, filehandle; qbyte *buf = NULL; char *ptr, *token; netadr_t adr; char adrString[64]; qboolean favorite = qfalse; filelen = FS_FOpenFile( SERVERSFILE, &filehandle, FS_READ ); if( !filehandle || filelen < 1 ) { FS_FCloseFile( filehandle ); } else { buf = Mem_TempMalloc( filelen + 1 ); filelen = FS_Read( buf, filelen, filehandle ); FS_FCloseFile( filehandle ); } if( !buf ) return; ptr = ( char * )buf; while( ptr ) { token = COM_ParseExt( &ptr, qtrue ); if( !token[0] ) break; if( !Q_stricmp( token, "master" ) ) { favorite = qfalse; continue; } if( !Q_stricmp( token, "favorites" ) ) { favorite = qtrue; continue; } if( NET_StringToAddress( token, &adr ) ) { Q_strncpyz( adrString, token, sizeof( adrString ) ); token = COM_ParseExt( &ptr, qfalse ); if( !token[0] ) continue; if( favorite ) CL_AddServerToList( &favoritesList, adrString, (unsigned int)atoi( token ) ); else CL_AddServerToList( &masterList, adrString, (unsigned int)atoi( token ) ); } } Mem_TempFree( buf ); }
/* ================= S_OpenBackgroundTrack ================= */ static qboolean S_OpenBackgroundTrack (char *name, bgTrack_t *track) { OggVorbis_File *vorbisFile; vorbis_info *vorbisInfo; ov_callbacks vorbisCallbacks = {ovc_read, ovc_seek, ovc_close, ovc_tell}; #ifdef OGG_DIRECT_FILE char filename[1024]; char *path = NULL; #endif // Com_Printf("Opening background track: %s\n", name); #ifdef OGG_DIRECT_FILE do { path = FS_NextPath( path ); Com_sprintf( filename, sizeof(filename), "%s/%s", path, name ); if ( (track->file = fopen(filename, "rb")) != 0) break; } while ( path ); #else FS_FOpenFile(name, &track->file); #endif if (!track->file) { Com_Printf("S_OpenBackgroundTrack: couldn't find %s\n", name); return false; } track->vorbisFile = vorbisFile = Z_Malloc(sizeof(OggVorbis_File)); // Com_Printf("Opening callbacks for background track\n"); // bombs out here- ovc_read, FS_Read 0 bytes error if (ov_open_callbacks(track, vorbisFile, NULL, 0, vorbisCallbacks) < 0) { Com_Printf("S_OpenBackgroundTrack: couldn't open OGG stream (%s)\n", name); return false; } // Com_Printf("Getting info for background track\n"); vorbisInfo = ov_info(vorbisFile, -1); if (vorbisInfo->channels != 1 && vorbisInfo->channels != 2) { Com_Printf("S_OpenBackgroundTrack: only mono and stereo OGG files supported (%s)\n", name); return false; } track->start = ov_raw_tell(vorbisFile); track->rate = vorbisInfo->rate; track->width = 2; track->channels = vorbisInfo->channels; // Knightmare added track->format = (vorbisInfo->channels == 2) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16; // Com_Printf("Vorbis info: frequency: %i channels: %i bitrate: %i\n", // vorbisInfo->rate, vorbisInfo->channels, vorbisInfo->bitrate_nominal); return true; }
/* ================== SV_BeginDemoServer ================== */ void SV_BeginDemoserver(void){ char name[MAX_OSPATH]; Com_sprintf(name, sizeof(name), "demos/%s", sv.name); FS_FOpenFile(name, &sv.demofile); if(!sv.demofile) Com_Error(ERR_DROP, "Couldn't open %s\n", name); }
/* * Con_Dump_f * * Save the console contents out to a file */ static void Con_Dump_f( void ) { int file; size_t buffer_size; char *buffer; size_t name_size; char *name; const char *newline = "\r\n"; if( !con_initialized ) return; if( Cmd_Argc() != 2 ) { Com_Printf( "usage: condump <filename>\n" ); return; } name_size = sizeof( char ) * ( strlen( Cmd_Argv( 1 ) ) + strlen( ".txt" ) + 1 ); name = Mem_TempMalloc( name_size ); Q_strncpyz( name, Cmd_Argv( 1 ), name_size ); COM_DefaultExtension( name, ".txt", name_size ); COM_SanitizeFilePath( name ); if( !COM_ValidateRelativeFilename( name ) ) { Com_Printf( "Invalid filename.\n" ); Mem_TempFree( name ); return; } if( FS_FOpenFile( name, &file, FS_WRITE ) == -1 ) { Com_Printf( "Couldn't open: %s\n", name ); Mem_TempFree( name ); return; } buffer_size = Con_BufferText( NULL, newline ) + 1; buffer = Mem_TempMalloc( buffer_size ); Con_BufferText( buffer, newline ); FS_Write( buffer, buffer_size - 1, file ); FS_FCloseFile( file ); Mem_TempFree( buffer ); Com_Printf( "Dumped console text: %s\n", name ); Mem_TempFree( name ); }
struct sfx_s *S_RegisterSexedSound (entity_state_t *ent, char *base) { int n; char *p; struct sfx_s *sfx; FILE *f; char model[MAX_QPATH]; char sexedFilename[MAX_QPATH]; char maleFilename[MAX_QPATH]; // determine what model the client is using model[0] = 0; n = CS_PLAYERSKINS + ent->number - 1; if (cl.configstrings[n][0]) { p = strchr(cl.configstrings[n], '\\'); if (p) { p += 1; strcpy(model, p); p = strchr(model, '/'); if (p) *p = 0; } } // if we can't figure it out, they're male if (!model[0]) strcpy(model, "male"); // see if we already know of the model specific sound Com_sprintf (sexedFilename, sizeof(sexedFilename), "#players/%s/%s", model, base+1); sfx = S_FindName (sexedFilename, false); if (!sfx) { // no, so see if it exists FS_FOpenFile (&sexedFilename[1], &f); if (f) { // yes, close the file and register it FS_FCloseFile (f); sfx = S_RegisterSound (sexedFilename); } else { // no, revert to the male sound in the pak0.pak Com_sprintf (maleFilename, sizeof(maleFilename), "player/%s/%s", "male", base+1); sfx = S_AliasName (sexedFilename, maleFilename); } } return sfx; }
/* * ML_Restart * Restart map list stuff */ void ML_Restart( bool forcemaps ) { ML_Shutdown(); if( forcemaps ) { int filenum; if( FS_FOpenFile( MLIST_CACHE, &filenum, FS_WRITE|FS_CACHE ) != -1 ) FS_FCloseFile( filenum ); } FS_Rescan(); ML_Init(); }
/* * CL_DownloadRequest * * Request file download * return qfalse if couldn't request it for some reason * Files with .pk3 or .pak extension have to have gamedir attached * Other files must not have gamedir */ qboolean CL_DownloadRequest( const char *filename, qboolean requestpak ) { if( cls.download.requestname ) { Com_Printf( "Can't download: %s. Download already in progress.\n", filename ); return qfalse; } if( !COM_ValidateRelativeFilename( filename ) ) { Com_Printf( "Can't download: %s. Invalid filename.\n", filename ); return qfalse; } if( FS_CheckPakExtension( filename ) ) { if( FS_FOpenBaseFile( filename, NULL, FS_READ ) != -1 ) { Com_Printf( "Can't download: %s. File already exists.\n", filename ); return qfalse; } if( !Q_strnicmp( COM_FileBase( filename ), "modules", strlen( "modules" ) ) ) { if( !CL_CanDownloadModules() ) return qfalse; } } else { if( FS_FOpenFile( filename, NULL, FS_READ ) != -1 ) { Com_Printf( "Can't download: %s. File already exists.\n", filename ); return qfalse; } } if( cls.socket->type == SOCKET_LOOPBACK ) { Com_DPrintf( "Can't download: %s. Loopback server.\n", filename ); return qfalse; } Com_Printf( "Asking to download: %s\n", filename ); cls.download.requestpak = requestpak; cls.download.requestname = Mem_ZoneMalloc( sizeof( char ) * ( strlen( filename ) + 1 ) ); Q_strncpyz( cls.download.requestname, filename, sizeof( char ) * ( strlen( filename ) + 1 ) ); cls.download.timeout = Sys_Milliseconds() + 5000; CL_AddReliableCommand( va( "download %i \"%s\"", requestpak, filename ) ); return qtrue; }
void SV_ReadServerFile(void) { fileHandle_t f; char name[MAX_OSPATH], string[128]; char comment[32]; char mapcmd[MAX_TOKEN_CHARS]; Com_DPrintf("SV_ReadServerFile()\n"); Com_sprintf(name, sizeof(name), "save/current/server.ssv"); FS_FOpenFile(name, &f, FS_READ); if (!f) { Com_Printf("Couldn't read %s\n", name); return; } /* read the comment field */ FS_Read(comment, sizeof(comment), f); /* read the mapcmd */ FS_Read(mapcmd, sizeof(mapcmd), f); /* read all CVAR_LATCH cvars these will be things like coop, skill, deathmatch, etc */ while (1) { char cvarname[LATCH_CVAR_SAVELENGTH] = {0}; if (!FS_FRead(cvarname, 1, sizeof(cvarname), f)) { break; } FS_Read(string, sizeof(string), f); Com_DPrintf("Set %s = %s\n", cvarname, string); Cvar_ForceSet(cvarname, string); } FS_FCloseFile(f); /* start a new game fresh with new cvars */ SV_InitGame(); strcpy(svs.mapcmd, mapcmd); /* read game state */ Com_sprintf(name, sizeof(name), "%s/save/current/game.ssv", FS_Gamedir()); ge->ReadGame(name); }
/* * CL_WriteServerCache */ void CL_WriteServerCache( void ) { serverlist_t *server; int filehandle; char str[256]; netadr_t adr; if( FS_FOpenFile( SERVERSFILE, &filehandle, FS_WRITE ) == -1 ) { Com_Printf( "CL_WriteServerList: Couldn't create the cache file\n" ); return; } Q_snprintfz( str, sizeof( str ), "// servers cache file generated by %s. Do not modify\n", APPLICATION ); FS_Print( filehandle, str ); FS_Print( filehandle, "master\n" ); server = masterList; while( server ) { if( server->lastValidPing + 7 > Com_DaysSince1900() ) { if( NET_StringToAddress( server->address, &adr ) ) { Q_snprintfz( str, sizeof( str ), "%s %i\n", server->address, (int)server->lastValidPing ); FS_Print( filehandle, str ); } } server = server->pnext; } FS_Print( filehandle, "favorites\n" ); server = favoritesList; while( server ) { if( server->lastValidPing + 7 > Com_DaysSince1900() ) { if( NET_StringToAddress( server->address, &adr ) ) { Q_snprintfz( str, sizeof( str ), "%s %i\n", server->address, (int)server->lastValidPing ); FS_Print( filehandle, str ); } } server = server->pnext; } FS_FCloseFile( filehandle ); }
qboolean FS_FileExists(char *path) { fileHandle_t f; FS_FOpenFile(path, &f, FS_READ); if (f != 0) { FS_FCloseFile(f); return true; } return false; }
static qboolean SV_FilenameForDownloadRequest( const char *requestname, qboolean requestpak, const char **uploadname, const char **errormsg ) { if( FS_CheckPakExtension( requestname ) ) { if( !requestpak ) { *errormsg = "Pak file requested as a non pak file"; return qfalse; } if( FS_FOpenBaseFile( requestname, NULL, FS_READ ) == -1 ) { *errormsg = "File not found"; return qfalse; } *uploadname = requestname; } else { if( FS_FOpenFile( requestname, NULL, FS_READ ) == -1 ) { *errormsg = "File not found"; return qfalse; } // check if file is inside a PAK if( requestpak ) { *uploadname = FS_PakNameForFile( requestname ); if( !*uploadname ) { *errormsg = "File not available in pack"; return qfalse; } } else { *uploadname = FS_BaseNameForFile( requestname ); if( !*uploadname ) { *errormsg = "File only available in pack"; return qfalse; } } } return qtrue; }
/* * SCR_PlayCinematic */ static void SCR_PlayCinematic( char *arg ) { int len; size_t name_size; static cinematics_t clientCin; cinematics_t *cin = cl.cin = &clientCin; roq_chunk_t *chunk = &cin->chunk; name_size = strlen( "video/" ) + strlen( arg ) + strlen( ".roq" ) + 1; cin->name = Mem_ZoneMalloc( name_size ); Q_snprintfz( cin->name, name_size, "video/%s", arg ); COM_DefaultExtension( cin->name, ".roq", name_size ); // nasty hack cin->s_rate = 22050; cin->s_width = 2; cin->width = cin->height = 0; cin->frame = 0; len = FS_FOpenFile( cin->name, &cin->file, FS_READ ); if( !cin->file || len < 1 ) { Com_Printf( "Couldn't find %s\n", cin->name ); SCR_StopCinematic(); return; } // read header RoQ_ReadChunk( cin ); if( chunk->id != RoQ_HEADER1 || chunk->size != RoQ_HEADER2 || chunk->argument != RoQ_HEADER3 ) { Com_Printf( "Invalid video file %s\n", cin->name ); SCR_StopCinematic(); return; } SCR_EndLoadingPlaque(); cin->headerlen = FS_Tell( cin->file ); cin->frame = 0; cin->pic = cin->pic_pending = SCR_ReadNextCinematicFrame(); cin->time = cls.realtime + 1; // add 1 msec so SCR_GetCinematicTime is also valid for early commands CL_SetClientState( CA_ACTIVE ); CL_SoundModule_StopAllSounds(); }
/* ============== SV_ReadServerFile ============== */ void SV_ReadServerFile (void) { fileHandle_t f; char fileName[MAX_OSPATH], varName[128], string[128]; char comment[32]; char mapcmd[MAX_TOKEN_CHARS]; Com_DPrintf("SV_ReadServerFile()\n"); Com_sprintf (fileName, sizeof(fileName), "save/current/server.ssv"); FS_FOpenFile (fileName, &f, FS_READ); if (!f) { Com_Printf ("Couldn't read %s\n", fileName); return; } // read the comment field FS_Read (comment, sizeof(comment), f); // read the mapcmd FS_Read (mapcmd, sizeof(mapcmd), f); // read all CVAR_LATCH cvars // these will be things like coop, skill, deathmatch, etc while (1) { if (!FS_FRead (varName, 1, sizeof(varName), f)) break; FS_Read (string, sizeof(string), f); Com_DPrintf ("Set %s = %s\n", varName, string); Cvar_ForceSet (varName, string); } FS_FCloseFile(f); // start a new game fresh with new cvars SV_InitGame (); // strncpy (svs.mapcmd, mapcmd); Q_strncpyz (svs.mapcmd, mapcmd, sizeof(svs.mapcmd)); // read game state Com_sprintf (fileName, sizeof(fileName), "%s/save/current/game.ssv", FS_Gamedir()); ge->ReadGame (fileName); }
//handle a map <mapname> command from the console or progs. void SV_Map_f (void) { char level[MAX_QPATH], expanded[MAX_QPATH]; #ifndef WITH_FTE_VFS FILE *f; #else vfsfile_t *f; #endif qbool devmap; if (Cmd_Argc() != 2) { Com_Printf ("%s <levelname> : continue game on a new level\n", Cmd_Argv(0)); return; } devmap = !strcasecmp (Cmd_Argv(0), "devmap"); strlcpy (level, Cmd_Argv(1), sizeof(level)); // check to make sure the level exists snprintf (expanded, sizeof(expanded), "maps/%s.bsp", level); #ifndef WITH_FTE_VFS if (FS_FOpenFile (expanded, &f) == -1) { Com_Printf ("Can't find %s\n", expanded); return; } fclose (f); #else if (!(f = FS_OpenVFS(expanded, "rb", FS_ANY))) { Com_Printf ("Can't find %s\n", expanded); return; } VFS_CLOSE(f); #endif // WITH_FTE_VFS #ifndef SERVERONLY if (!dedicated) CL_BeginLocalConnection (); #endif SV_BroadcastCommand ("changing\n"); SV_SendMessagesToAll (); SV_SpawnServer (level, devmap); SV_BroadcastCommand ("reconnect\n"); }
void Create_Savestrings(void) { int i; fileHandle_t f; char name[MAX_OSPATH]; char mapname[MAX_TOKEN_CHARS]; char *ch; for (i = 0; i < MAX_SAVEGAMES; i++) { Com_sprintf(name, sizeof(name), "save/kmq2save%i/server.ssv", i); FS_FOpenFile(name, &f, FS_READ); if (!f) { //Com_Printf("Save file %s not found.\n", name); strcpy(m_savestrings[i], "<EMPTY>"); m_savevalid[i] = false; } else { FS_Read(m_savestrings[i], sizeof(m_savestrings[i]), f); if (i == 0) // grab mapname { FS_Read(mapname, sizeof(mapname), f); if (mapname[0] == '*') // skip * marker { Com_sprintf(m_mapname, sizeof(m_mapname), mapname + 1); } else { Com_sprintf(m_mapname, sizeof(m_mapname), mapname); } ch = strchr(m_mapname, '$'); if (ch) { *ch = 0; // terminate string at $ marker } } FS_FCloseFile(f); m_savevalid[i] = true; } } }
void ReadTextureSurfaceAssignments() { char filename[MAX_OSPATH]; FILE *f; char line[80]; num_texsurfs = 0; Com_sprintf (filename, sizeof(filename), "texsurfs.txt"); FS_FOpenFile (filename, &f); if (!f) return; while (fgets(line, sizeof(line), f) && num_texsurfs < MAX_TEX_SURF) { sscanf(line,"%d %s",&tex_surf[num_texsurfs].step_id,tex_surf[num_texsurfs].tex); //Com_Printf("%d %s\n",tex_surf[num_texsurfs].step_id,tex_surf[num_texsurfs].tex); num_texsurfs++; } fclose(f); }
/* ============ FS_LoadFile Filename are reletive to the quake search path a null buffer will just return the file length without loading ============ */ int EXPORT FS_LoadFile (const char *path, void /*@out@*/ /*@null@*/**buffer) { FILE *h; byte *buf; int len; qboolean closeHandle; // look for it in the filesystem or pack files //START_PERFORMANCE_TIMER; //Com_Printf ("%s... ", path); len = FS_FOpenFile (path, &h, buffer ? HANDLE_OPEN : HANDLE_NONE, &closeHandle); //STOP_PERFORMANCE_TIMER; //Com_Printf ("TOTAL SO FAR: %.5f\n", totalTime); if (len == -1) { if (buffer) *buffer = NULL; return -1; } if (!buffer) return len; if (!len) { fclose (h); Com_Printf ("WARNING: 0 byte file: %s\n", LOG_GENERAL|LOG_WARNING, path); *buffer = CopyString ("", TAGMALLOC_FSLOADFILE); return 0; } buf = Z_TagMalloc(len, TAGMALLOC_FSLOADFILE); *buffer = buf; current_filename = path; FS_Read (buf, len, h); current_filename = "unknown"; if (closeHandle) fclose (h); return len; }
//FIXME: this is bad, loads entire file for just 8 bytes! qboolean GetWalInfo (const char *name, int *width, int *height) { miptex_t mt; qboolean closeFile; FILE *h; FS_FOpenFile (name, &h, HANDLE_OPEN, &closeFile); if (!h) return false; /*if (fread (&mt, sizeof(mt), 1, h) != 1) { ri.FS_FCloseFile (h); return false; }*/ FS_Read (&mt, sizeof(mt), h); if (closeFile) FS_FCloseFile (h); *width = LittleLong(mt.width); *height = LittleLong(mt.height); #if defined(_DEBUG) && !defined(EMSCRIPTEN) int i; char grey = 8; FS_CreatePath (va("wals/%s", name)); h = fopen (va("wals/%s", name), "wb"); fwrite (&mt, 1, sizeof(mt), h); for (i = 0; i < mt.width * mt.height; i++) fwrite (&grey, 1, 1, h); for (i = 0; i < (mt.width * mt.height) / 2; i++) fwrite (&grey, 1, 1, h); for (i = 0; i < (mt.width * mt.height) / 4; i++) fwrite (&grey, 1, 1, h); for (i = 0; i < (mt.width * mt.height) / 8; i++) fwrite (&grey, 1, 1, h); fclose (h); #endif return true; }