/////////////////// // Load the weapons restrictions list void CWpnRest::loadList(const std::string& szFilename, const std::string& moddir) { // Shutdown the list first Shutdown(); std::string fn = szFilename; if(!strCaseStartsWith(fn, "cfg/")) { if(fn.size() > 4 && !stringcaseequal(fn.substr(fn.size()-4), ".wps")) fn += ".wps"; if(moddir != "" && IsFileAvailable("cfg/presets/" + moddir + "/" + fn)) fn = "cfg/presets/" + moddir + "/" + fn; else fn = "cfg/presets/" + fn; } FILE *fp = OpenGameFile(fn, "rt"); if( !fp ) return; std::string line; while( !feof(fp) && !ferror(fp) ) { line = ReadUntil(fp, '\n'); std::vector<std::string> exploded = explode(line,","); if (exploded.size() >= 2) addWeapon(exploded[0],from_string<int>(exploded[1])); } fclose(fp); // Sort the list sortList(); }
///////////////////////// // Initializes the IRC client and connects to the server (specified in options) bool InitializeIRC() { // Already initialized? if (globalIRC) return true; if (!tLXOptions->bEnableChat) return false; // Allocate the IRC client try { globalIRC = new IRCClient(); } catch (...) { return false; } // Get the server FILE *fp = OpenGameFile("cfg/chatserver.txt", "r"); if (fp) { std::string addr = ReadUntil(fp, '/'); std::string chann = ReadUntil(fp, '\n'); fclose(fp); return globalIRC->connect(addr, chann, tLXOptions->sLastSelectedPlayer); } else { // Defaults return globalIRC->connect("irc.quakenet.org", "#LieroX", tLXOptions->sLastSelectedPlayer); } }
/** * This function loads the savegame of the 5th version */ bool CSaveGameController::loadSaveGameVersion5(const std::string &fname, OldSaveGameFormatV5& old) { FILE *fp; unsigned char episode, level, lives, numplayers; g_pLogFile->ftextOut("Loading game from file %s\n", fname.c_str()); fp = OpenGameFile(fname, "rb"); if (!fp) { g_pLogFile->ftextOut("unable to open %s\n",fname.c_str()); return false; } readOldHeader(fp, &episode, &level, &lives, &numplayers); g_pLogFile->ftextOut("game_load: restoring structures...\n"); /*primaryplayer =*/ fgetc(fp); // primary player doesn't exist anymore! Jump that! sgrle_compress(fp, (unsigned char *) &old.LevelControl, sizeof(old.LevelControl)); // note that we don't have to load the LEVEL, because the state // of the map is already saved inside the save-game. sgrle_initdecompression(); if (sgrle_decompressV2(fp, (unsigned char *) &old.LevelControl, sizeof(old.LevelControl))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.scroll_x, sizeof(old.scroll_x))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.scrollx_buf, sizeof(old.scrollx_buf))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.scrollpix, sizeof(old.scrollpix))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.mapx, sizeof(old.mapx))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.mapxstripepos, sizeof(old.mapxstripepos))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.scroll_y, sizeof(old.scroll_y))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.scrolly_buf, sizeof(old.scrolly_buf))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.scrollpixy, sizeof(old.scrollpixy))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.mapy, sizeof(old.mapy))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.mapystripepos, sizeof(old.mapystripepos))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.max_scroll_x, sizeof(old.max_scroll_x))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.max_scroll_y, sizeof(old.max_scroll_y))) return false; if (sgrle_decompressV2(fp, (unsigned char *)&old.map, sizeof(old.map))) return false; unsigned char *tempbuf; tempbuf = new unsigned char[22624]; /*highest_objslot = */fgetc(fp); fgetc(fp); // Not used anymore since objects are held in an vector. if (sgrle_decompressV2(fp, (unsigned char *)tempbuf, 22624)) return false; if (sgrle_decompressV2(fp, (unsigned char *)tempbuf, 9612)) return false; delete [] tempbuf; if (sgrle_decompressV2(fp, (unsigned char *)&old.Player, sizeof(old.Player))) return false; fclose(fp); return true; }
// Opens *existing* file from given directory in a case-insensitive manner /*static*/ BE_FILE_T BEL_Cross_open_from_dir(const char *filename, bool isOverwriteRequest, const char *searchdir) { std::string filePath = searchdir; filePath += "/"; filePath += filename; return OpenGameFile(filePath, isOverwriteRequest ? "wb" : "rb"); /*** TODO - Any reason to save (cache) DIR handles? ***/ /* DIR *dir; struct dirent *direntry; dir = opendir(searchdir); if (!dir) return NULL; char fullpath[BE_CROSS_PATH_LEN_BOUND]; for (direntry = readdir(dir); direntry; direntry = readdir(dir)) { if (!BE_Cross_strcasecmp(direntry->d_name, filename)) { // Just a little sanity check if (strlen(searchdir) + 1 + strlen(direntry->d_name) >= BE_CROSS_PATH_LEN_BOUND) { closedir(dir); return NULL; } char *fullpathEnd = fullpath + sizeof(fullpath); BE_Cross_safeandfastcstringcopy_3strs(fullpath, fullpathEnd, searchdir, "/", direntry->d_name); closedir(dir); return fopen(fullpath, isOverwriteRequest ? "wb" : "rb"); } } closedir(dir); // If tried to open for reading, we return NULL, otherwise we attempt create new file if (!isOverwriteRequest) return NULL; char *fullpathEnd = fullpath + sizeof(fullpath); char *fullpathPtr = BE_Cross_safeandfastcstringcopy_2strs(fullpath, fullpathEnd, searchdir, "/"); // Create actual new files with a lower case, just because that's a common pattern in Unix-like setups // (basically a modified BE_Cross_safeandfastcstringcopy). // // Note: fullpathPtr should initially point to an instance of '\0', so fullpathPtr < fullpathEnd. char ch; do { ch = *filename++; *fullpathPtr++ = BE_Cross_tolower(ch); // This includes the null terminator if there's the room } while ((fullpathPtr < fullpathEnd) && ch); // These work in case fullpathPtr == fullpathEnd, and also if not --fullpathPtr; *fullpathPtr = '\0'; return fopen(fullpath, "wb");*/ }
/////////////////// // Save the weapons restrictions list void CWpnRest::saveList(const std::string& szFilename) { // Save it as plain text FILE *fp = OpenGameFile(szFilename, "wt"); if( !fp ) return; for( std::list<wpnrest_t> :: iterator it = m_psWeaponList.begin(); it != m_psWeaponList.end(); it++ ) fprintf(fp, "%s,%d\n", it->szName.c_str(), it->nState); fclose(fp); }
//////////////// // Loads the database, returns false on failure bool GeoIPDatabase::load(const std::string& filename) { m_file = OpenGameFile(filename, "rb"); if (!m_file) return false; m_fileName = filename; if (!setupSegments()) { fclose(m_file); return false; } return true; }
bool CSaveGameController::loadSaveGameVersion4(const std::string &fname, OldSaveGameFormatV4& old) { FILE *fp; //unsigned char episode, level, lives; unsigned int numplayers; g_pLogFile->ftextOut("Loading game from file %s\n", fname.c_str()); fp = OpenGameFile(fname, "rb"); if (!fp) { g_pLogFile->ftextOut("unable to open %s\n",fname.c_str()); return false; } g_pLogFile->ftextOut("game_load: restoring structures...\n"); if (fgetc(fp) != 'S') { fclose(fp); return false; } if (fgetc(fp) != OLDSAVEGAMEVERSION4) { fclose(fp); return false; } fgetc(fp); // load all structures from the file sgrle_initdecompression(); sgrle_decompressV1(fp, (unsigned char *)&numplayers, sizeof(numplayers)); sgrle_decompressV1(fp, (unsigned char *)&old.LevelControl, sizeof(old.LevelControl)); sgrle_decompressV1(fp, (unsigned char *)&old.scroll_x, sizeof(old.scroll_x)); sgrle_decompressV1(fp, (unsigned char *)&old.scroll_y, sizeof(old.scroll_y)); sgrle_decompressV1(fp, (unsigned char *)&old.max_scroll_x, sizeof(old.max_scroll_x)); sgrle_decompressV1(fp, (unsigned char *)&old.max_scroll_y, sizeof(old.max_scroll_y)); sgrle_decompressV1(fp, (unsigned char *)&old.map, sizeof(old.map)); //initgame( &(pCKP->Control.levelcontrol) ); // reset scroll //drawmap(); //for(i=0;i<scrx;i++) map_scroll_right(); //for(i=0;i<scry;i++) map_scroll_down(); sgrle_decompressV1(fp, (unsigned char *)&old.Player, sizeof(old.Player)); //sgrle_decompress(fp, (unsigned char *)&objects[0], sizeof(objects)); //sgrle_decompress(fp, (unsigned char *)&tiles[0], sizeof(tiles)); fclose(fp); return true; }
void LoadCDTrackList() { //clear out the old list first EmptyCDTrackList(); FILE *file = OpenGameFile(CDTrackFileName, FILEMODE_READONLY, FILETYPE_OPTIONAL); if(file==NULL) { LOGDXFMT(("Failed to open %s",CDTrackFileName)); return; } char* buffer; int file_size; fseek(file, 0, SEEK_END); file_size = ftell(file); rewind(file); //copy the file contents into a buffer buffer=new char[file_size+1]; fread(buffer, 1, file_size, file); fclose(file); // NULL terminate buffer. buffer[file_size] = '\0'; char* bufferptr=buffer; //first extract the multiplayer tracks for(int i=0;i<3;i++) { ExtractTracksForLevel(bufferptr,MultiplayerCDTracks[i]); } //now the level tracks for(int i=0 ;i<AVP_ENVIRONMENT_END_OF_LIST;i++) { ExtractTracksForLevel(bufferptr,LevelCDTracks[i]); } delete [] buffer; }
bool CSaveGameController::IsOldSGVersion4(const std::string& fname) { FILE* fp = OpenGameFile(fname, "rb"); if (!fp) return false; if (fgetc(fp) != 'S') { fclose(fp); return false; } if (fgetc(fp) != OLDSAVEGAMEVERSION4) { fclose(fp); return false; } fclose(fp); return true; }
bool CSaveGameController::IsOldSGVersion5(const std::string& fname) { const char *verify = "CKSAVE"; FILE* fp = OpenGameFile(fname, "rb"); if (!fp) return false; for(size_t i=0; i < strlen(verify); i++) { char c = fgetc(fp); if (c != verify[i]) { fclose(fp); return false; } printf("%c", c); } if (fgetc(fp) != OLDSAVEGAMEVERSION5) { fclose(fp); return false; } fclose(fp); return true; }
void ScreenShot() { int i; char Name[40]; int width, height; unsigned char *buf = GetScreenShot24(&width, &height); if (buf == NULL) return; strcpy(Name,"avp"); int length=strlen(Name); strncpy(&Name[length],"00.bmp",8); for(i=0;i<100;i++) { Name[length]=i/10+'0'; Name[length+1]=(i%10)+'0'; FILE* tempfp = OpenGameFile(Name, FILEMODE_READONLY, FILETYPE_CONFIG); if(!tempfp)break; else { fclose(tempfp); } } if(i==100) return; FILE *fp = OpenGameFile(Name, FILEMODE_WRITEONLY, FILETYPE_CONFIG); if (!fp) { return; } BMPHEADER2 h; // fill out header h.Header.Type = 'B'+'M'*256; h.Header.Reserved1 = 0; h.Header.Reserved2 = 0; h.Header.Offset = 14+40+0; /* ** The type of information found in a BMP structure is indicated by ** the Size (Information Headere Size) field with a non-zero value. */ h.PmInfo.Size = 0; h.Pm2Info.Size = 0; h.WinInfo.Size = 40; h.WinInfo.Width = width; h.WinInfo.Height = height; h.WinInfo.Planes = 1; h.WinInfo.BitCount = 24; h.WinInfo.Compression = 0; h.WinInfo.SizeImage = h.WinInfo.Width*h.WinInfo.Height*3; h.WinInfo.XPelsPerMeter = h.WinInfo.Width; h.WinInfo.YPelsPerMeter = h.WinInfo.Height; h.WinInfo.ClrUsed = 0; h.WinInfo.ClrImportant = 0; h.Header.FileSize = h.WinInfo.SizeImage + h.Header.Offset + 8; // write header PutWord_F PutWord = PutLittleWord; PutDword_F PutDword = PutLittleDword; PutWord(h.Header.Type, fp); PutDword(h.Header.FileSize, fp); PutWord(h.Header.Reserved1, fp); PutWord(h.Header.Reserved2, fp); PutDword(h.Header.Offset, fp); PutDword(h.WinInfo.Size, fp); PutDword(h.WinInfo.Width, fp); PutDword(h.WinInfo.Height, fp); PutWord(h.WinInfo.Planes, fp); PutWord(h.WinInfo.BitCount, fp); PutDword(h.WinInfo.Compression, fp); PutDword(h.WinInfo.SizeImage, fp); PutDword(h.WinInfo.XPelsPerMeter, fp); PutDword(h.WinInfo.YPelsPerMeter, fp); PutDword(h.WinInfo.ClrUsed, fp); PutDword(h.WinInfo.ClrImportant, fp); // write 24 bit image // unsigned char *BufferPtr = &buf[(width * 3) * (height - 1)]; unsigned char *BufferPtr = &buf[0]; for (i=h.WinInfo.Height-1; i>=0; --i) { unsigned int j; for (j=0; j<h.WinInfo.Width; ++j) { PutByte((BYTE)BufferPtr[j*3+2],fp); //b PutByte((BYTE)BufferPtr[j*3+1],fp); //g PutByte((BYTE)BufferPtr[j*3],fp); //r } // pad to 4 byte boundary for (j=~(h.WinInfo.Width*3-1) & 3; j; --j) PutByte(0,fp); // BufferPtr -= width * 3; BufferPtr += width * 3; } free(buf); fclose(fp); }
bool CEGASprit::loadData(const std::string& filename, bool compresseddata) { byte *RawData; SDL_Surface *sfc; Uint8* pixel; Uint32 percent = 0; FILE* latchfile = OpenGameFile(filename.c_str(),"rb"); if(!latchfile) return false; gResourceLoader.setPermilage(10); RawData = new byte[m_planesize * 5]; // get the data out of the file into the memory, decompressing it if necessary. if (compresseddata) { if (lz_decompress(latchfile, RawData)) return 1; } else { for(int i=0 ; i<(m_planesize*5) ; i++) RawData[i] = fgetc(latchfile); } fclose(latchfile); gResourceLoader.setPermilage(50); // TODO: Try to blit the Font map here! // these are the offsets of the different video planes as // relative to each other--that is if a pixel in plane1 // is at N, the byte for that same pixel in plane3 will be // at (N + plane3). unsigned long plane1, plane2, plane3, plane4, plane5; plane1 = 0; plane2 = (m_planesize * 1); plane3 = (m_planesize * 2); plane4 = (m_planesize * 3); plane5 = (m_planesize * 4); CPlanes Planes(RawData + m_spriteloc); Planes.setOffsets(plane1, plane2, plane3, plane4, plane5); // load the image data gGraphics.createEmptySprites(4,MAX_SPRITES+1); for(int i=0 ; i<m_numsprites ; i++) { GsSprite &Sprite = gGraphics.getSprite(0,i); Sprite.setSize( EGASpriteModell[i].width, EGASpriteModell[i].height ); Sprite.setBoundingBoxCoordinates( (EGASpriteModell[i].hitbox_l << STC), (EGASpriteModell[i].hitbox_u << STC), (EGASpriteModell[i].hitbox_r << STC), (EGASpriteModell[i].hitbox_b << STC) ); Sprite.createSurface( gVideoDriver.mpVideoEngine->getBlitSurface()->flags, gGraphics.Palette.m_Palette ); percent = (i*50)/m_numsprites; gResourceLoader.setPermilage(50+percent); } gResourceLoader.setPermilage(100); for(int p=0 ; p<4 ; p++) { for(int s=0 ; s<m_numsprites ; s++) { sfc = gGraphics.getSprite(0,s).getSDLSurface(); if(SDL_MUSTLOCK(sfc)) SDL_LockSurface(sfc); pixel = (Uint8*) sfc->pixels; Planes.readPlane(p, pixel, sfc->w, sfc->h); if(SDL_MUSTLOCK(sfc)) SDL_UnlockSurface(sfc); percent = (s*100)/m_numsprites; gResourceLoader.setPermilage(100+percent); } } gResourceLoader.setPermilage(200); // now load the 5th plane, which contains the sprite masks. // note that we invert the mask because our graphics functions // use white on black masks whereas keen uses black on white. for(int s=0 ; s<m_numsprites ; s++) { GsSprite &Sprite = gGraphics.getSprite(0,s); SDL_Surface *pixsfc = Sprite.getSDLSurface(); SDL_Surface *masksfc = Sprite.getSDLMaskSurface(); if(SDL_MUSTLOCK(pixsfc)) SDL_LockSurface(pixsfc); if(SDL_MUSTLOCK(masksfc)) SDL_LockSurface(masksfc); pixel = (Uint8*) masksfc->pixels; for(int y=0 ; y<masksfc->h ; y++) { for(int x=0 ; x<masksfc->w ; x++) { if(Planes.getbit(4)) pixel[y*masksfc->w + x] = ((Uint8*)pixsfc->pixels)[y*pixsfc->w + x]; else pixel[y*masksfc->w + x] = 15; } } if(SDL_MUSTLOCK(masksfc)) SDL_UnlockSurface(masksfc); if(SDL_MUSTLOCK(pixsfc)) SDL_UnlockSurface(pixsfc); percent = (s*100)/m_numsprites; gResourceLoader.setPermilage(200+percent); } gResourceLoader.setPermilage(300); if(RawData){ delete[] RawData; RawData = NULL;} LoadSpecialSprites( gGraphics.getSpriteVec(0) ); for(unsigned int i=1 ; i<4 ; i++) { gGraphics.getSpriteVec(i) = gGraphics.getSpriteVec(0); } // For the other variant let's exchange some colors auto &SpriteVecPlayer2 = gGraphics.getSpriteVec(1); for( unsigned int i = 0 ; i < SpriteVecPlayer2.size() ; i++) { auto &sprite = SpriteVecPlayer2[i]; // Red against Purple sprite.exchangeSpriteColor( 5, 4, 0 ); sprite.exchangeSpriteColor( 13, 12, 0 ); // Yellow against Green sprite.exchangeSpriteColor( 2, 6, 0 ); sprite.exchangeSpriteColor( 10, 14, 0 ); } auto &SpriteVecPlayer3 = gGraphics.getSpriteVec(2); for( auto &sprite : SpriteVecPlayer3) { // Red against Green sprite.exchangeSpriteColor( 2, 4, 0 ); sprite.exchangeSpriteColor( 10, 12, 0 ); // Yellow against Purple sprite.exchangeSpriteColor( 5, 6, 0 ); sprite.exchangeSpriteColor( 13, 14, 0 ); } auto &SpriteVecPlayer4 = gGraphics.getSpriteVec(3); for( auto &sprite : SpriteVecPlayer4) { // Red against Yellow sprite.exchangeSpriteColor( 6, 4, 0 ); sprite.exchangeSpriteColor( 14, 12, 0 ); // Green against Purple sprite.exchangeSpriteColor( 2, 5, 0 ); sprite.exchangeSpriteColor( 10, 13, 0 ); } for(unsigned int i=0 ; i<4 ; i++) { for(Uint16 s=0 ; s<gGraphics.getSpriteVec(i).size() ; s++) { GsSprite &Sprite = gGraphics.getSprite(i,s); Sprite.optimizeSurface(); percent = (s*50)/m_numsprites; gResourceLoader.setPermilage(300+percent); } } gResourceLoader.setPermilage(350); std::set<std::string> filelist; FileListAdder fileListAdder; std::string gfxpath = JoinPaths(m_gamepath, "gfx"); GetFileList(filelist, fileListAdder, gfxpath, false, FM_REG); FilterFilelist(filelist, "sprite"); std::set<std::string>::iterator it = filelist.begin(); int listsize = filelist.size(); for( int c=0 ; it != filelist.end() ; it++, c++ ) { std::string name=*it; if(name.find("_") != name.npos) continue; int num = getRessourceID(name, "sprite"); if(num < m_numsprites ) { GsSprite &Sprite = gGraphics.getSprite(0, num); std::string filename = getResourceFilename("gfx/"+name, m_gamepath, false, true); Sprite.loadHQSprite(filename); } percent = (c*150)/listsize; gResourceLoader.setPermilage(350+percent); } gResourceLoader.setPermilage(500); for(unsigned int i=0 ; i<4 ; i++) { const int NoSprites = gGraphics.getSpriteVec(i).size(); for(Uint16 s=0 ; s<NoSprites ; s++) { gGraphics.getSprite(i,s).applyTransparency(); percent = (s*250)/NoSprites; gResourceLoader.setPermilage(500+percent); } } gResourceLoader.setPermilage(750); // Now create special sprites, like those for effects and the doors! DeriveSpecialSprites( gGraphics.getTileMap(1), gGraphics.getSpriteVec(0) ); gResourceLoader.setPermilage(800); // Here special Effects are applied, only when the option is enabled for it if(gVideoDriver.getSpecialFXConfig()) ApplySpecialFX(); gResourceLoader.setPermilage(900); // Apply the sprites for player 2,3 and 4 DerivePlayerSprites( 1,gGraphics.getSpriteVec(1) ); DerivePlayerSprites( 2,gGraphics.getSpriteVec(2) ); DerivePlayerSprites( 3,gGraphics.getSpriteVec(3) ); gResourceLoader.setPermilage(1000); return true; }
FILE* gusOpenGameFile(const std::string& path, const char *mode) { return OpenGameFile(path, mode); }
bool CEGALatch::loadData( const std::string &path, const short episode, const int version, const unsigned char *data, const bool compresseddata ) { std::string filename; byte *RawData; Uint16 width, height; SDL_Surface *sfc; filename = getResourceFilename("egalatch.ck" + itoa(episode), path); FILE* latchfile = OpenGameFile(filename,"rb"); if(!latchfile) return false; RawData = new byte[m_latchplanesize * 4]; // get the data out of the file into the memory, decompressing it if necessary. if (compresseddata) { if (lz_decompress(latchfile, (unsigned char*) RawData)) { return 1; } } else { for(int i=0 ; i<(m_latchplanesize*4) ; i++) RawData[i] = fgetc(latchfile); } fclose(latchfile); // these are the offsets of the different video planes as // relative to each other--that is if a pixel in plane1 // is at N, the byte for that same pixel in plane3 will be // at (N + plane3). unsigned long plane1, plane2, plane3, plane4; plane1 = 0; plane2 = (m_latchplanesize * 1); plane3 = (m_latchplanesize * 2); plane4 = (m_latchplanesize * 3); // ** read the 8x8 tiles ** // set up the getbit() function of CPlanes class CPlanes Planes(RawData); Planes.setOffsets(plane1 + m_fontlocation, plane2 + m_fontlocation, plane3 + m_fontlocation, plane4 + m_fontlocation, 0); // Load these graphics into the GsFont Class of GsGraphics // The original vorticon engine only uses one fontmap, but we use another for // extra icons. For example sliders are in that map gGraphics.freeFonts(); gGraphics.createEmptyFontmaps(3); gGraphics.getFont(0).loadinternalFont(); GsFont &Font = gGraphics.getFont(1); Font.CreateSurface( gGraphics.Palette.m_Palette, SDL_SWSURFACE ); sfc = Font.getSDLSurface(); gGraphics.getFont(2).loadAlternateFont(); if(SDL_MUSTLOCK(sfc)) SDL_LockSurface(sfc); Uint8 *pixel = (Uint8*) sfc->pixels; SDL_FillRect(sfc, NULL, 0); for(int p=0;p<4;p++) Planes.readPlaneofTiles(p, pixel, 16, 8, m_fonttiles); if(SDL_MUSTLOCK(sfc)) SDL_UnlockSurface(sfc); // prepare to ** read the 16x16 tiles ** Planes.setOffsets(plane1 + m_tiles16location, plane2 + m_tiles16location, plane3 + m_tiles16location, plane4 + m_tiles16location, 0); gGraphics.freeTilemap(); gGraphics.createEmptyTilemaps(2); loadTilemap(gGraphics.getTileMap(0), Planes, episode, path); // prepare to ** read the 16x16 tiles **, this is for the second plane. Planes.setOffsets(plane1 + m_tiles16location, plane2 + m_tiles16location, plane3 + m_tiles16location, plane4 + m_tiles16location, 0); loadTilemap(gGraphics.getTileMap(1), Planes, episode, path); gGraphics.getTileMap(0).optimizeSurface(); gGraphics.getTileMap(1).optimizeSurface(); // make masked tiles according to it's surfaces applyMasks(); //////////////////// /// Load Bitmaps /// //////////////////// Planes.setOffsets(plane1 + m_bitmaplocation, plane2 + m_bitmaplocation, plane3 + m_bitmaplocation, plane4 + m_bitmaplocation, 0); // decode bitmaps into the BitmapData structure. The bitmaps are // loaded into one continuous stream of image data, with the bitmaps[] // array giving pointers to where each bitmap starts within the stream. for(int p=0 ; p<4 ; p++) { for(int b=0 ; b<m_bitmaps ; b++) { GsBitmap &bitmap = gGraphics.getBitmapFromId(b); // this points to the location that we're currently // decoding bitmap data to sfc= bitmap.getSDLSurface(); if(SDL_MUSTLOCK(sfc)) SDL_LockSurface(sfc); Uint8* pixel = (Uint8*) sfc->pixels; if(p==0) SDL_FillRect(sfc, NULL, 0); width = bitmap.getWidth(); height = bitmap.getHeight(); // Now read the raw data Planes.readPlane(p, pixel, width, height); if(SDL_MUSTLOCK(sfc)) SDL_UnlockSurface(sfc); } } std::set<std::string> filelist; FileListAdder fileListAdder; std::string gfxpath = JoinPaths(path, "gfx"); GetFileList(filelist, fileListAdder, gfxpath, false, FM_REG); FilterFilelist(filelist, "bitmap"); std::set<std::string>::iterator it = filelist.begin(); for( ; it != filelist.end() ; it++ ) { std::string filename=*it; int num = getRessourceID(filename, "bitmap"); GsBitmap &bitmap = gGraphics.getBitmapFromId(num); filename = getResourceFilename("gfx/" + filename, path, false); bitmap.loadHQBitmap(filename); } if(RawData){ delete[] RawData; RawData = NULL;} // Create an intro in case it does not exist yet std::string fullpath = getResourceFilename("preview.bmp", path, false); if( fullpath == "" ) { // Not found create it fullpath = path + "/preview.bmp"; fullpath = GetWriteFullFileName(fullpath, true); GsBitmap *pBitmap = gGraphics.getBitmapFromStr("TITLE"); SDL_SaveBMP( pBitmap->getSDLSurface(), fullpath.c_str()); } return true; }
bool CEGALatch::loadData( std::string &path, short episode, int version, unsigned char *data, bool compresseddata ) { std::string filename; byte *RawData; Uint16 width, height; SDL_Surface *sfc; filename = getResourceFilename("egalatch.ck" + itoa(episode), path); FILE* latchfile = OpenGameFile(filename,"rb"); if(!latchfile) return false; RawData = new byte[m_latchplanesize * 4]; // get the data out of the file into the memory, decompressing it if necessary. if (compresseddata) { if (lz_decompress(latchfile, (unsigned char*) RawData)) { return 1; } } else { for(int i=0 ; i<(m_latchplanesize*4) ; i++) RawData[i] = fgetc(latchfile); } fclose(latchfile); // these are the offsets of the different video planes as // relative to each other--that is if a pixel in plane1 // is at N, the byte for that same pixel in plane3 will be // at (N + plane3). unsigned long plane1, plane2, plane3, plane4; plane1 = 0; plane2 = (m_latchplanesize * 1); plane3 = (m_latchplanesize * 2); plane4 = (m_latchplanesize * 3); // ** read the 8x8 tiles ** // set up the getbit() function of CPlanes class CPlanes Planes(RawData); Planes.setOffsets(plane1 + m_fontlocation, plane2 + m_fontlocation, plane3 + m_fontlocation, plane4 + m_fontlocation, 0); // Load these graphics into the CFont Class of CGfxEngine // The original vorticon engine only uses one fontmap, but we use another for // extra icons. For example sliders are in that map g_pGfxEngine->freeFonts(); g_pGfxEngine->createEmptyFontmaps(3); g_pGfxEngine->getFont(0).loadinternalFont(); CFont &Font = g_pGfxEngine->getFont(1); Font.CreateSurface( g_pGfxEngine->Palette.m_Palette, SDL_SWSURFACE ); sfc = Font.getSDLSurface(); g_pGfxEngine->getFont(2).loadAlternateFont(); if(SDL_MUSTLOCK(sfc)) SDL_LockSurface(sfc); Uint8 *pixel = (Uint8*) sfc->pixels; SDL_FillRect(sfc, NULL, 0); for(int p=0;p<4;p++) Planes.readPlaneofTiles(p, pixel, 16, 8, m_fonttiles); if(SDL_MUSTLOCK(sfc)) SDL_UnlockSurface(sfc); // ** read the 16x16 tiles ** Planes.setOffsets(plane1 + m_tiles16location, plane2 + m_tiles16location, plane3 + m_tiles16location, plane4 + m_tiles16location, 0); g_pGfxEngine->freeTilemap(); g_pGfxEngine->createEmptyTilemap(2); CTilemap &Tilemap = g_pGfxEngine->getTileMap(1); Tilemap.CreateSurface( g_pGfxEngine->Palette.m_Palette, SDL_SWSURFACE, m_num16tiles, 4, 13 ); sfc = Tilemap.getSDLSurface(); SDL_FillRect(sfc,NULL, 0); if(SDL_MUSTLOCK(sfc)) SDL_LockSurface(sfc); Uint8 *u_pixel = (Uint8*) sfc->pixels; for(int p=0;p<4;p++) Planes.readPlaneofTiles(p, u_pixel, 13, 16, m_num16tiles); if(SDL_MUSTLOCK(sfc)) SDL_UnlockSurface(sfc); // Load Hi-Colour, VGA, SVGA Tiles into the tilemap filename = getResourceFilename("gfx/ck" + itoa(episode) + "tiles.bmp", path, false); if(Tilemap.loadHiresTile(filename)) g_pLogFile->textOut(GREEN, "VGA Bitmap for Tileset has been loaded successfully!"); // Adapt the tilemap to the display, so they are faster blit Tilemap.optimizeSurface(); // make masked tiles according to it's surfaces applyMasks(); //////////////////// /// Load Bitmaps /// //////////////////// Planes.setOffsets(plane1 + m_bitmaplocation, plane2 + m_bitmaplocation, plane3 + m_bitmaplocation, plane4 + m_bitmaplocation, 0); // decode bitmaps into the BitmapData structure. The bitmaps are // loaded into one continuous stream of image data, with the bitmaps[] // array giving pointers to where each bitmap starts within the stream. for(int p=0 ; p<4 ; p++) { for(int b=0 ; b<m_bitmaps ; b++) { CBitmap &bitmap = g_pGfxEngine->getBitmap(b); // this points to the location that we're currently // decoding bitmap data to sfc= bitmap.getSDLSurface(); if(SDL_MUSTLOCK(sfc)) SDL_LockSurface(sfc); Uint8* pixel = (Uint8*) sfc->pixels; if(p==0) SDL_FillRect(sfc, NULL, 0); width = bitmap.getWidth(); height = bitmap.getHeight(); // Now read the raw data Planes.readPlane(p, pixel, width, height); if(SDL_MUSTLOCK(sfc)) SDL_UnlockSurface(sfc); } } // optimize the bitmaps and load hq bitmaps if there are some. for(int b=0 ; b<m_bitmaps ; b++) { CBitmap &bitmap = g_pGfxEngine->getBitmap(b); bitmap.optimizeSurface(); } std::set<std::string> filelist; FileListAdder fileListAdder; std::string gfxpath = JoinPaths(path, "gfx"); GetFileList(filelist, fileListAdder, gfxpath, false, FM_REG); FilterFilelist(filelist, "bitmap"); std::set<std::string>::iterator it = filelist.begin(); for( ; it != filelist.end() ; it++ ) { std::string filename=*it; int num = getRessourceID(filename, "bitmap"); CBitmap &bitmap = g_pGfxEngine->getBitmap(num); filename = getResourceFilename("gfx/" + filename, path, false); bitmap.loadHQBitmap(filename); } if(RawData){ delete[] RawData; RawData = NULL;} return true; }
FFError FFHeaderI::Read(char const *_filename) { if (_filename) { if (filename) delete[] filename; filename = new char [strlen(_filename)+1]; strcpy(filename,_filename); } FILE *h = OpenGameFile(filename, FILEMODE_READONLY, FILETYPE_PERM); if (h == NULL) { ReportError(filename); return FF_COULDNOTOPENFILE; } // reset vars Clear(); char magic[4]; unsigned long rffl_version; size_t num_files; size_t total_headsize; DWORD bytes_read; READ_FILE(filename,(void)0,fclose(h),h,magic,4,bytes_read,0) READ_FILE(filename,(void)0,fclose(h),h,&rffl_version,4,bytes_read,0) READ_FILE(filename,(void)0,fclose(h),h,&num_files,4,bytes_read,0) READ_FILE(filename,(void)0,fclose(h),h,&total_headsize,4,bytes_read,0) READ_FILE(filename,(void)0,fclose(h),h,&length,4,bytes_read,0) if (strncmp(magic,"RFFL",4)) { ReportError(filename,"Incorrect file type"); fclose(h); return FF_COULDNOTREADFILE; } if (rffl_version>0) { ReportError(filename,"Version not supported"); fclose(h); return FF_COULDNOTREADFILE; } void * header = malloc(total_headsize); READ_FILE(filename,(void)0,fclose(h),h,header,total_headsize,bytes_read,0) data = malloc(length); READ_FILE(filename,(void)0,fclose(h),h,data,length,bytes_read,0) fclose(h); // now parse the header void * headerP = header; for (unsigned int i=0; i<num_files; ++i) { char const * fnameP = (char *)((size_t)headerP + 8); size_t leng = *(size_t *)((size_t)headerP + 4); void * dataP = (void *)((size_t)data + *(size_t *)headerP); files[HashFunction(fnameP)].add_entry(FFDataI(fnameP,dataP,leng)); // increment pointer headerP = (void *)((size_t)headerP + 8 + strlen(fnameP) +4&~3); } free(header); return FF_OK; }
/** * \brief loads a 32-bit uncompressed RGBA targa file, and return a pointer to * the raw image data. The width and height of the image are returned as well. * \param filename Name to the file that will used to read the picture * \param image Pointer to an array that will contain the image data. This array will be allocated * \param width Width of the picture that will be set after the picture was read * \param height Same here for the height */ bool LoadTGA(const std::string& filename, Uint8 **image, Uint16 &width, Uint16 &height) { TGA_HEADER header; FILE *fp; uint bytes_per_pixel; unsigned long img_data_size; // First check if the files exists if ((fp=OpenGameFile(filename, "rb")) == NULL) return false; // read the header header.identsize = fgetc(fp); fgetc(fp); header.imagetype = fgetc(fp); fgeti(fp); fgeti(fp); fgetc(fp); header.xstart = fgeti(fp); header.ystart = fgeti(fp); header.width = fgeti(fp); header.height = fgeti(fp); header.bpp = fgetc(fp); fgetc(fp); // Check if the header meet our requirements if (header.imagetype != TGA_RGB) { g_pLogFile->textOut(PURPLE,"<br>LoadTGA: " + filename + ": imagetype must be RGBA uncompressed!<br>"); fclose(fp); return false; } if (header.bpp != 32) { g_pLogFile->textOut(PURPLE,"<br>LoadTGA: " + filename + ": image bpp must be 32 (RGB w/ alpha channel)<br>"); fclose(fp); return false; } // Set some variables values so the pictures can be used outside this code width = header.width; height = header.height; bytes_per_pixel = (header.bpp / 8); img_data_size = header.width * header.height * bytes_per_pixel; // allocate memory for the image buffer *image = new byte [img_data_size]; if (*image == NULL) { fclose(fp); return false; } // Read the picture data const uint elem_read = fread(*image, img_data_size, 1, fp); fclose(fp); // Check if the picture was read correctly if(elem_read != 1) { delete [] *image; *image = NULL; return false; } else return true; }
Sprite_Header_Chunk::Sprite_Header_Chunk(const char * file_name, Chunk_With_Children * parent) : Chunk_With_Children(parent,"SPRIHEAD") { // Load in whole chunk and traverse FILE *rif_file; DWORD file_size; DWORD file_size_from_file; char * buffer; char * buffer_ptr; char id_buffer[9]; Parent_File = this; error_code = 0; rif_file = OpenGameFile(file_name, FILEMODE_READONLY, FILETYPE_PERM); if (rif_file == NULL) { return; } fseek(rif_file, 0, SEEK_END); file_size = ftell(rif_file); rewind(rif_file); if (fread(id_buffer, 1, 8, rif_file) != 8) { error_code = CHUNK_FAILED_ON_LOAD; fclose(rif_file); return; } if (strncmp(id_buffer, "SPRIHEAD", 8) != 0) { error_code = CHUNK_FAILED_ON_LOAD_NOT_RECOGNISED; fclose(rif_file); return; } if (fread(&file_size_from_file, 1, 4, rif_file) != 4) { error_code = CHUNK_FAILED_ON_LOAD; fclose(rif_file); return; } if (file_size != file_size_from_file) { error_code = CHUNK_FAILED_ON_LOAD_NOT_RECOGNISED; fclose(rif_file); return; } buffer = new char [file_size]; if (fread(buffer, 1, (file_size-12), rif_file) != (file_size-12)) { error_code = CHUNK_FAILED_ON_LOAD; delete [] buffer; fclose(rif_file); return; } fclose(rif_file); // Process the file buffer_ptr = buffer; // The start of the first chunk while ((buffer_ptr-buffer)< ((signed) file_size-12) && !error_code) { if ((*(int *)(buffer_ptr + 8)) + (buffer_ptr-buffer) > ((signed) file_size-12)) { error_code = CHUNK_FAILED_ON_LOAD_NOT_RECOGNISED; break; } DynCreate(buffer_ptr); buffer_ptr += *(int *)(buffer_ptr + 8); } delete [] buffer; }
bool IniReader::Parse() { FILE* f = OpenGameFile(m_filename, "r"); if(f == NULL) return false; bool res = true; enum ParseState { S_DEFAULT, S_IGNORERESTLINE, S_PROPNAME, S_PROPVALUE, S_SECTION }; ParseState state = S_DEFAULT; std::string propname; std::string section; std::string value; while(!feof(f) && !ferror(f)) { unsigned char c = 0; if(fread(&c, 1, 1, f) == 0) break; if(c == '\r') continue; // ignore this switch(state) { case S_DEFAULT: if(c >= 128) break; // just ignore unicode-stuff when we are in this state (UTF8 bytes at beginning are also handled by this) else if(isspace(c)) break; // ignore spaces and newlines else if(c == '#') { state = S_IGNORERESTLINE; /* this is a comment */ break; } else if(c == '[') { state = S_SECTION; section = ""; break; } else if(c == '=') { warnings << "WARNING: \"=\" is not allowed as the first character in a line of " << m_filename << endl; break; /* ignore */ } else { state = S_PROPNAME; propname = c; break; } case S_SECTION: if(c == ']') { if( ! OnNewSection(section) ) { res = false; goto parseCleanup; } state = S_DEFAULT; NewSection(section); break; } else if(c == '\n') { warnings << "WARNING: section-name \"" << section << "\" of " << m_filename << " is not closed correctly" << endl; state = S_DEFAULT; break; } else if(isspace(c)) { warnings << "WARNING: section-name \"" << section << "\" of " << m_filename << " contains a space" << endl; break; /* ignore */ } else { section += c; break; } case S_PROPNAME: if(c == '\n') { warnings << "WARNING: property \"" << propname << "\" of " << m_filename << " incomplete" << endl; state = S_DEFAULT; break; } else if(isspace(c)) break; // just ignore spaces else if(c == '=') { state = S_PROPVALUE; value = ""; break; } else { propname += c; break; } case S_PROPVALUE: if(c == '\n' || c == '#') { if( ! OnEntry(section, propname, value) ) { res = false; goto parseCleanup; } NewEntryInSection(propname, value); if(c == '#') state = S_IGNORERESTLINE; else state = S_DEFAULT; break; } else if(isspace(c) && value == "") break; // ignore heading spaces else { value += c; break; } case S_IGNORERESTLINE: if(c == '\n') state = S_DEFAULT; break; // ignore everything } } // In case the endline is missing at the end of file, finish the parsing of the last line if (state == S_PROPVALUE) { if( ! OnEntry(section, propname, value) ) { res = false; goto parseCleanup; } NewEntryInSection(propname, value); } // DEBUG: dump the file /*notes << "Dump of " << m_filename << endl; for (SectionMap::iterator it = m_sections.begin(); it != m_sections.end(); ++it) { notes << "[" << it->first << "]" << endl; for (Section::iterator k = it->second.begin(); k != it->second.end(); ++k) notes << k->first << "=" << k->second << endl; notes << endl; } notes << endl;*/ parseCleanup: fclose(f); return res; }
/////////////////// // Read a string static bool GetString(const std::string& filename, const std::string& section, const std::string& key, std::string& string, bool abs_fn) { FILE *config = NULL; std::string Line; std::string tmpLine; std::string curSection; std::string temp; std::string curKey; size_t chardest = 0; int Position; bool found = false; if(filename == "") return false; if(abs_fn) { config = OpenGameFile(filename.c_str(), "rt"); } else config = OpenGameFile(filename,"rt"); if(!config) return false; //string=""; curSection=""; temp=""; curKey=""; // Check for UTF-8 encoded file and skip the UTF-8 mark if it is unsigned char utf8mark[3] = {0,0,0}; if(fread(utf8mark, sizeof(utf8mark), 1, config) == 0) { fclose(config); return false; } if (utf8mark[0] != 0xEF || utf8mark[1] != 0xBB || utf8mark[2] != 0xBF) fseek(config, 0, SEEK_SET); // Not a UTF-8 file, jump back to the beginning while(!feof(config) && !ferror(config)) { // Parse the lines Line = ReadUntil(config, '\n'); TrimSpaces(Line); /////////////////// // Comment, Ignore if(Line.size() == 0 || Line[0] == '#') continue; //////////// // Sections if(Line[0] == '[' && Line[Line.size()-1] == ']') { curSection = Line.substr(1); curSection.erase(curSection.size()-1); continue; } //////// // Keys chardest = Line.find('='); if(chardest != std::string::npos) { // Key Position = (int)chardest; tmpLine = Line; tmpLine.erase(Position); TrimSpaces(tmpLine); curKey = tmpLine; // Check if this is the key were looking for under the section were looking for if(stringcasecmp(curKey,key) == 0 && stringcasecmp(curSection,section) == 0) { // Get the value tmpLine = Line.substr(Position+1); TrimSpaces(tmpLine); string = tmpLine; found = true; break; } continue; } } fclose(config); return found; }