/** * fügt einen Eintrag hinzu. * * @param[in] name Variablenname * @param[in] value Wert */ void libsiedler2::ArchivItem_Ini::addValue(const std::string& name, const std::string& value) { ArchivItem_Text* item = dynamic_cast<ArchivItem_Text*>( getAllocator().create(BOBTYPE_TEXT) ); item->setText(value); item->setName(name); push(item); }
void libsiedler2::ArchivItem_Ini::setValue(const std::string& name, const std::string& value) { ArchivItem_Text* item = dynamic_cast<ArchivItem_Text*>(find(name)); if(item) { // setText überschreibt Namen, daher nochmals setzen item->setText(value); item->setName(name); } else { // nicht gefunden, also hinzufügen addValue(name, value); } }
/** * lädt eine spezifizierten Bobtype aus einer Datei in ein ArchivItem. * * @param[in] bobtype Typ des Items * @param[in] file Filehandle auf die auszulesende Datei * @param[in] palette Grundpalette * @param[out] item ArchivItem-Struktur, welche gefüllt wird * * @return Null bei Erfolg, ein Wert ungleich Null bei Fehler */ int libsiedler2::loader::LoadType(BOBTYPES bobtype, std::istream& file, const ArchivItem_Palette* palette, ArchivItem*& item) { if(!file) return 1; try{ switch(bobtype) { case BOBTYPE_SOUND: // WAVs, MIDIs { libendian::LittleEndianIStreamRef fs(file); unsigned int length; fs >> length; baseArchivItem_Sound* nitem = baseArchivItem_Sound::findSubType(file); if(!nitem || nitem->load(file, length) != 0){ delete nitem; return 5; } item = nitem; } break; case BOBTYPE_BITMAP_RLE: // RLE komprimiertes Bitmap { baseArchivItem_Bitmap_RLE* nitem = dynamic_cast<baseArchivItem_Bitmap_RLE*>(getAllocator().create(BOBTYPE_BITMAP_RLE)); if(nitem->load(file, palette) != 0){ delete nitem; return 6; } item = nitem; } break; case BOBTYPE_FONT: // Font { ArchivItem_Font* nitem = dynamic_cast<ArchivItem_Font*>(getAllocator().create(BOBTYPE_FONT)); if(nitem->load(file, palette) != 0){ delete nitem; return 7; } item = nitem; } break; case BOBTYPE_BITMAP_PLAYER: // Bitmap mit spezifischer Spielerfarbe { ArchivItem_Bitmap_Player* nitem = dynamic_cast<ArchivItem_Bitmap_Player*>(getAllocator().create(BOBTYPE_BITMAP_PLAYER)); if(nitem->load(file, palette) != 0){ delete nitem; return 8; } item = nitem; } break; case BOBTYPE_PALETTE: // Palette { ArchivItem_Palette* nitem = dynamic_cast<ArchivItem_Palette*>(getAllocator().create(BOBTYPE_PALETTE)); if(nitem->load(file) != 0){ delete nitem; return 9; } item = nitem; } break; case BOBTYPE_BOB: // Bobfile { ArchivItem_Bob* nitem = dynamic_cast<ArchivItem_Bob*>(getAllocator().create(BOBTYPE_BOB)); if(nitem->load(file, palette) != 0){ delete nitem; return 10; } item = nitem; } break; case BOBTYPE_BITMAP_SHADOW: // Schatten { baseArchivItem_Bitmap_Shadow* nitem = dynamic_cast<baseArchivItem_Bitmap_Shadow*>(getAllocator().create(BOBTYPE_BITMAP_SHADOW)); if(nitem->load(file, palette) != 0){ delete nitem; return 11; } item = nitem; } break; case BOBTYPE_MAP: // Mapfile { ArchivItem_Map* nitem = dynamic_cast<ArchivItem_Map*>(getAllocator().create(BOBTYPE_MAP)); if(nitem->load(file, false) != 0){ delete nitem; return 12; } item = nitem; } break; case BOBTYPE_TEXT: // Textfile { ArchivItem_Text* nitem = dynamic_cast<ArchivItem_Text*>(getAllocator().create(BOBTYPE_TEXT)); if(nitem->load(file) != 0){ delete nitem; return 13; } item = nitem; } break; case BOBTYPE_BITMAP_RAW: // unkomprimiertes Bitmap { baseArchivItem_Bitmap_Raw* nitem = dynamic_cast<baseArchivItem_Bitmap_Raw*>(getAllocator().create(BOBTYPE_BITMAP_RAW)); if(nitem->load(file, palette) != 0){ delete nitem; return 14; } item = nitem; } break; case BOBTYPE_NONE: item = NULL; break; default: item = NULL; return 42; } if(item != NULL) item->setBobType(bobtype); }catch(std::runtime_error&){ // Mostly error on reading (e.g. unexpected end of file) return 999; } return 0; }
/** * lädt eine GER/ENG-File in ein ArchivInfo. * * @param[in] file Dateiname der GER/ENG-File * @param[out] items ArchivInfo-Struktur, welche gefüllt wird * @param[in] conversion Soll ggf. OEM-Charset in ANSI umgewandelt werden? * * @return Null bei Erfolg, ein Wert ungleich Null bei Fehler * * @bug Keine Erkennung ob Plain-Text oder "Irgendwas". * * @author FloSoft */ int libsiedler2::loader::LoadTXT(const char* file, ArchivInfo* items, bool conversion) { FILE* txt; short header; long length; if(file == NULL || items == NULL) return 1; // Datei zum lesen öffnen txt = fopen(file, "rb"); // hat das geklappt? if(txt == NULL) return 2; // Länge bestimmen fseek(txt, 0, SEEK_END); length = ftell(txt); fseek(txt, 0, SEEK_SET); // Header einlesen if(libendian::be_read_s(&header, txt) != 0) return 3; // ist es eine TXT-File? (Header 0xE7FD) if( header != (short)0xE7FD ) { // den Header zurückspringen fseek(txt, -2, SEEK_CUR); // Plain-Text items->alloc(1); ArchivItem_Text* item = (ArchivItem_Text*)(*allocator)(BOBTYPE_TEXT, 0, NULL); item->load(txt, conversion); // Item erzeugen items->set(0, item); } else { // "archiviert" unsigned short count, unknown; unsigned int size; if(libendian::le_read_us(&count, txt) != 0) return 4; if(libendian::le_read_us(&unknown, txt) != 0) return 5; if(libendian::le_read_ui(&size, txt) != 0) return 6; if(size == 0) size = length; else size += 10; // Anzahl alloziieren items->alloc(count); int* starts = new int[count]; memset(starts, 0, sizeof(int)*count); // Starts einlesen for(unsigned short x = 0; x < count; ++x) { int s; if(libendian::le_read_i(&s, txt) != 0) return 7; if(s != 0) starts[x] = s + 10; } // Daten einlesen, zwecks Längenbestimmung unsigned int pos = ftell(txt); unsigned int rest = size - pos; char* buffer = new char[rest + 1]; if(libendian::le_read_c(buffer, rest, txt) != (int)rest) return 8; for(unsigned short x = 0; x < count; ++x) { int i = starts[x]; if(i != 0) { // An Start springen fseek(txt, i, SEEK_SET); // einlesen ArchivItem_Text* item = (ArchivItem_Text*)(*allocator)(BOBTYPE_TEXT, 0, NULL); item->load(txt, conversion, (unsigned int)strlen(&buffer[i - pos])); items->set(x, item); } else items->set(x, (ArchivItem_Text*)(*allocator)(BOBTYPE_TEXT, 0, NULL)); } delete[] buffer; delete[] starts; } // alles ok return 0; }
/** * lädt die INI-Daten aus einer Datei. * * @param[in] file Dateihandle der Datei * * @return liefert Null bei Erfolg, ungleich Null bei Fehler */ int libsiedler2::ArchivItem_Ini::load(std::istream& file) { if(!file) return 1; std::string section; std::getline(file, section); size_t lr = section.find('\r'); if (lr != std::string::npos) section.erase(lr, 1); size_t ln = section.find('\n'); if (ln != std::string::npos) section.erase(ln, 1); if(!section.empty()) { size_t pos = section.find('['); if(pos == std::string::npos) throw std::runtime_error("Invalid section"); section = section.substr(pos + 1); pos = section.find(']'); if(pos == std::string::npos) throw std::runtime_error("Invalid section"); section = section.substr(0, pos); } if(section.empty() && !file.eof()) return 4; setName(section); if(!file) return 0; while(true) { std::string entry; if(!std::getline(file, entry)) break; lr = entry.find('\015'); if (lr != std::string::npos) entry.erase(lr, 1); ln = section.find('\n'); if (ln != std::string::npos) entry.erase(ln, 1); if(entry.empty()) break; size_t pos = entry.find('='); if(pos == std::string::npos) throw std::runtime_error("Invalid value"); std::string name = entry.substr(0, pos); std::string value = entry.substr(pos + 1); if(name.empty() || value.empty()) continue; ArchivItem_Text* item = dynamic_cast<ArchivItem_Text*>( getAllocator().create(BOBTYPE_TEXT) ); item->setText(value); item->setName(name); push(item); } return 0; }
/** * lädt eine GER/ENG-File in ein ArchivInfo. * * @param[in] file Dateiname der GER/ENG-File * @param[out] items ArchivInfo-Struktur, welche gefüllt wird * @param[in] conversion Soll ggf. OEM-Charset in ANSI umgewandelt werden? * * @return Null bei Erfolg, ein Wert ungleich Null bei Fehler * * @bug Keine Erkennung ob Plain-Text oder "Irgendwas". */ int libsiedler2::loader::LoadTXT(const std::string& file, ArchivInfo& items, bool conversion) { short header; if(file.empty()) return 1; // Datei zum lesen öffnen boost::iostreams::mapped_file_source mmapFile; try{ mmapFile.open(bfs::path(file)); }catch(std::exception& e){ std::cerr << "Could not open '" << file << "': " << e.what() << std::endl; return 2; } typedef boost::iostreams::stream<boost::iostreams::mapped_file_source> MMStream; MMStream mmapStream(mmapFile); libendian::EndianIStream<false, MMStream& > fs(mmapStream); // hat das geklappt? if(!fs) return 2; size_t length = getIStreamSize(fs.getStream()); assert(length < std::numeric_limits<unsigned>::max()); // Header einlesen fs >> header; items.clear(); // ist es eine TXT-File? (Header 0xE7FD) if( header != (short)0xFDE7 ) { // den Header zurückspringen fs.setPositionRel(-2); ArchivItem_Text* item = (ArchivItem_Text*)getAllocator().create(BOBTYPE_TEXT); item->load(fs.getStream(), conversion); items.push(item); } else { // "archiviert" unsigned short count, unknown; unsigned int size; fs >> count; fs >> unknown; fs >> size; if(size == 0) size = static_cast<unsigned>(length); else size += 10; std::vector<unsigned> starts(count); // Starts einlesen for(unsigned short x = 0; x < count; ++x) { uint32_t s; fs >> s; if(s != 0) starts[x] = s + 10; } // Daten einlesen, zwecks Längenbestimmung size_t pos = fs.getPosition(); size_t rest = size - pos; std::vector<char> buffer(rest + 1); buffer.resize(rest); fs >> buffer; buffer.push_back(0); for(unsigned short x = 0; x < count; ++x) { unsigned i = starts[x]; if(i != 0) { // An Start springen fs.setPosition(i); // einlesen ArchivItem_Text* item = (ArchivItem_Text*)getAllocator().create(BOBTYPE_TEXT); assert(i >= pos); item->load(fs.getStream(), conversion, (unsigned int)strlen(&buffer[i - pos]) + 1); items.push(item); } else items.push(NULL); } } // alles ok return 0; }