const void *Package::GetFile(const char *filename, u32 *filesize) { const void *file = NULL; const u8 *ptr = static_cast<const u8 *>(stFile.GetData()); SKIP_STRUCT(ObjectHeader, ptr); u32 foo; READ_U32(foo, ptr); for (u32 i = 0; i < iFilesAmount; i++) { u32 offset = 0; u32 size = 0; char *name = NULL; READ_U32(offset, ptr); READ_U32(size, ptr); READ_STR(name, ptr); if (!STRCMP(name, filename)) { const u8 *filePtr = static_cast<const u8 *>(stFile.GetData()); file = &filePtr[offset]; *filesize = size; break; } } return file; }
bool TextTable::SetTableData(VOID* pvTable, WCHAR* pwszSheetName, TYPE eType, BSTR bstrData) { if (0 == wcscmp(pwszSheetName, L"Table_Data_KOR")) { sTEXT_TBLDAT* pChatCommand = (sTEXT_TBLDAT*)pvTable; if (eType == INDEX) { pChatCommand->tblidx = READ_DWORD(bstrData); } else if (eType == TEXT) { if (false == READ_STR(pChatCommand->wstrText, bstrData)) { return false; } } else { _ASSERT(0); return false; } } else { _ASSERT(0); return false; } return true; }
int a_readprivate(attrib * a, void *owner, struct storage *store) { char lbuf[DISPLAYSIZE]; READ_STR(store, lbuf, sizeof(lbuf)); a->data.v = _strdup(lbuf); return (a->data.v) ? AT_READ_OK : AT_READ_FAIL; }
bool QuestTextDataTable::SetTableData(void* pvTable, WCHAR* pwszSheetName, std::wstring* pstrDataName, BSTR bstrData) { if (0 == wcscmp(pwszSheetName, L"Table_Data_KOR")) { sQUEST_TEXT_DATA_TBLDAT* pQuestTextData = (sQUEST_TEXT_DATA_TBLDAT*)pvTable; if (0 == wcscmp(pstrDataName->c_str(), L"Quest_Text_Index")) { pQuestTextData->tblidx = READ_TBLIDX(bstrData); } else if (0 == wcscmp(pstrDataName->c_str(), L"Quest_Text")) { if (false == READ_STR(pQuestTextData->wstrText, bstrData)) { return false; } } else { Table::CallErrorCallbackFunction(L"[File] : %s\n[Error] : Unknown field name found!(Field Name = %s)", m_wszXmlFileName, pstrDataName->c_str()); return false; } } else { return false; } return true; }
void read_groups(struct storage *store, faction * f) { for (;;) { ally **pa; group *g; int gid; char buf[1024]; READ_INT(store, &gid); if (gid == 0) break; READ_STR(store, buf, sizeof(buf)); g = new_group(f, buf, gid); pa = &g->allies; for (;;) { ally *a; variant fid; READ_INT(store, &fid.i); if (fid.i <= 0) break; a = ally_add(pa, findfaction(fid.i)); READ_INT(store, &a->status); if (!a->faction) ur_add(fid, &a->faction, resolve_faction); } a_read(store, &g->attribs, g); } }
void read_groups(struct storage *store, faction * f) { for (;;) { ally **pa; group *g; int gid; char buf[1024]; READ_INT(store, &gid); if (gid == 0) break; READ_STR(store, buf, sizeof(buf)); g = new_group(f, buf, gid); pa = &g->allies; for (;;) { ally *a; variant fid; READ_INT(store, &fid.i); if (fid.i <= 0) break; if (global.data_version < STORAGE_VERSION && fid.i == 0) break; a = malloc(sizeof(ally)); *pa = a; pa = &a->next; READ_INT(store, &a->status); a->faction = findfaction(fid.i); if (!a->faction) ur_add(fid, &a->faction, resolve_faction); } *pa = 0; a_read(store, &g->attribs, g); } }
void SoundSource::Load(const char *filename, ResourceManager *res, IMemoryPool *pool) { ASSERT_NULL(filename); ASSERT_NULL(pool); ASSERT_NULL(res); if (pSoundSystem->IsInitialized()) { this->Unload(); /* Open file .sound */ SECURITY_CHECK(pFileSystem->Open(filename, &stFile, pool), "Sound object couldn't be opened"); const u8 *ptr = static_cast<const u8 *>(stFile.GetData()); ObjectHeader *block = NULL; READ_STRUCT(block, ObjectHeader, ptr); SECURITY_CHECK(seed_validate_block(&stFile, block, SOUND_OBJECT_MAGIC, SOUND_OBJECT_VERSION), "Invalid block header for sound."); u32 volume = 0; READ_U32(volume, ptr); this->fVolume = volume / 100.0f; u32 flags = 0; READ_U32(flags, ptr); this->bLoop = ((flags & 0x01) == 0x01); // FIXME const char *fname = NULL; READ_STR(fname, ptr); ASSERT_NULL(fname); /* Get the resource */ pSound = static_cast<Sound *>(res->Get(fname, Seed::ObjectSound, pool)); if (iSource) alDeleteSources(1, &iSource); ALenum err = alGetError(); alGenSources(1, &iSource); err = alGetError(); if (err != AL_NO_ERROR) Info(TAG "Could not create OpenAL Source: %4x", err); const ALint *buffer = static_cast<const ALint *>(pSound->GetData()); alSourcef(iSource, AL_PITCH, 1.0f); alSource3f(iSource, AL_POSITION, cPosition.x, cPosition.y, cPosition.z); alSource3f(iSource, AL_VELOCITY, cVelocity.x, cVelocity.y, cVelocity.z); alSourcei(iSource, AL_LOOPING, this->bLoop); alSourcei(iSource, AL_BUFFER, *buffer); this->SetVolume(this->fVolume); } }
void IFileSystem::BuildFileTable() { if (!pFile) { pFile = New(File(FILESYSTEM_TABLE_FILE)); //ASSERT_NULL(pFile->pData); if (pFile->pData) { const u8 *ptr = static_cast<const u8 *>(pFile->pData); ObjectHeader *block = NULL; READ_STRUCT(block, ObjectHeader, ptr); SECURITY_CHECK(seed_validate_block(pFile, block, FST_OBJECT_MAGIC, FST_OBJECT_VERSION), "Invalid block header for filelist."); READ_U32(iLangCount, ptr); READ_U32(iFileCount, ptr); pFileTable = (StringFile *)pMemoryManager->Alloc(iLangCount * iFileCount * sizeof(const char *)); for (u32 l = 0; l < iLangCount; l++) { u32 lang = 0; READ_U32(lang, ptr); pLangTable[lang] = &pFileTable[l * iFileCount]; for (u32 s = 0; s < iFileCount; s++) { char *str = NULL; READ_STR(str, ptr); pFileTable[(l*iFileCount)+s] = str; } } pOldTable = pCurrentTable = pLangTable[pSystem->GetLanguage()]; pSystem->AddListener(this); } else { Info(TAG "Could not find %s, not using localization file table and file by id feature.", FILESYSTEM_TABLE_FILE); } } }
/** reads curses that have been removed from the code */ static int read_ccompat(const char *cursename, struct storage *store) { struct compat { const char *name; const char *tokens; } *seek, old_curses[] = { { "disorientationzone", ""}, { "shipdisorientation", ""}, { NULL, NULL}}; for (seek = old_curses; seek->name; ++seek) { if (strcmp(seek->tokens, cursename) == 0) { const char *p; for (p = seek->name; p; ++p) { switch (*p) { case 'd': READ_INT(store, 0); break; case 's': READ_STR(store, 0, 0); break; case 't': READ_TOK(store, 0, 0); break; case 'i': READ_INT(store, 0); break; case 'f': READ_FLT(store, 0); break; } } return 0; } } return -1; }
bool CXBTFReader::Open(const std::string& fileName) { m_fileName = fileName; #ifdef TARGET_WINDOWS std::wstring strPathW; g_charsetConverter.utf8ToW(CSpecialProtocol::TranslatePath(m_fileName), strPathW, false); m_file = _wfopen(strPathW.c_str(), L"rb"); #else m_file = fopen(m_fileName.c_str(), "rb"); #endif if (m_file == NULL) { return false; } char magic[4]; READ_STR(magic, 4, m_file); if (strncmp(magic, XBTF_MAGIC, sizeof(magic)) != 0) { return false; } char version[1]; READ_STR(version, 1, m_file); if (strncmp(version, XBTF_VERSION, sizeof(version)) != 0) { return false; } unsigned int nofFiles; READ_U32(nofFiles, m_file); for (unsigned int i = 0; i < nofFiles; i++) { CXBTFFile file; unsigned int u32; uint64_t u64; READ_STR(file.GetPath(), 256, m_file); READ_U32(u32, m_file); file.SetLoop(u32); unsigned int nofFrames; READ_U32(nofFrames, m_file); for (unsigned int j = 0; j < nofFrames; j++) { CXBTFFrame frame; READ_U32(u32, m_file); frame.SetWidth(u32); READ_U32(u32, m_file); frame.SetHeight(u32); READ_U32(u32, m_file); frame.SetFormat(u32); READ_U64(u64, m_file); frame.SetPackedSize(u64); READ_U64(u64, m_file); frame.SetUnpackedSize(u64); READ_U32(u32, m_file); frame.SetDuration(u32); READ_U64(u64, m_file); frame.SetOffset(u64); file.GetFrames().push_back(frame); } m_xbtf.GetFiles().push_back(file); m_filesMap[file.GetPath()] = file; } // Sanity check int64_t pos = ftell(m_file); if (pos != (int64_t)m_xbtf.GetHeaderSize()) { printf("Expected header size (%" PRId64") != actual size (%" PRId64")\n", m_xbtf.GetHeaderSize(), pos); return false; } return true; }
static int object_read(attrib * a, void *owner, struct storage *store) { char name[NAMESIZE]; object_data *data = (object_data *) a->data.v; int result, n; float flt; READ_STR(store, name, sizeof(name)); data->name = _strdup(name); READ_INT(store, &n); data->type = (object_type)n; switch (data->type) { case TINTEGER: READ_INT(store, &data->data.i); break; case TREAL: READ_FLT(store, &flt); data->data.real = flt; break; case TSTRING: READ_STR(store, name, sizeof(name)); data->data.str = _strdup(name); break; case TBUILDING: result = read_reference(&data->data.b, store, read_building_reference, resolve_building); if (result == 0 && !data->data.b) { return AT_READ_FAIL; } break; case TUNIT: result = read_reference(&data->data.u, store, read_unit_reference, resolve_unit); if (result == 0 && !data->data.u) { return AT_READ_FAIL; } break; case TFACTION: result = read_reference(&data->data.f, store, read_faction_reference, resolve_faction); if (result == 0 && !data->data.f) { return AT_READ_FAIL; } break; case TREGION: result = read_reference(&data->data.r, store, read_region_reference, RESOLVE_REGION(global.data_version)); if (result == 0 && !data->data.r) { return AT_READ_FAIL; } break; case TSHIP: /* return read_ship_reference(&data->data.sh, store); */ assert(!"not implemented"); break; case TNONE: break; default: return AT_READ_FAIL; } return AT_READ_OK; }
static struct manifest * read_manifest(gzFile f) { struct manifest *mf = create_empty_manifest(); uint32_t magic; READ_INT(4, magic); if (magic != MAGIC) { cc_log("Manifest file has bad magic number %u", magic); goto error; } READ_BYTE(mf->version); if (mf->version != MANIFEST_VERSION) { cc_log("Manifest file has unknown version %u", mf->version); goto error; } READ_BYTE(mf->hash_size); if (mf->hash_size != 16) { // Temporary measure until we support different hash algorithms. cc_log("Manifest file has unsupported hash size %u", mf->hash_size); goto error; } READ_INT(2, mf->reserved); READ_INT(4, mf->n_files); mf->files = x_calloc(mf->n_files, sizeof(*mf->files)); for (uint32_t i = 0; i < mf->n_files; i++) { READ_STR(mf->files[i]); } READ_INT(4, mf->n_file_infos); mf->file_infos = x_calloc(mf->n_file_infos, sizeof(*mf->file_infos)); for (uint32_t i = 0; i < mf->n_file_infos; i++) { READ_INT(4, mf->file_infos[i].index); READ_BYTES(mf->hash_size, mf->file_infos[i].hash); READ_INT(4, mf->file_infos[i].size); READ_INT(8, mf->file_infos[i].mtime); READ_INT(8, mf->file_infos[i].ctime); } READ_INT(4, mf->n_objects); mf->objects = x_calloc(mf->n_objects, sizeof(*mf->objects)); for (uint32_t i = 0; i < mf->n_objects; i++) { READ_INT(4, mf->objects[i].n_file_info_indexes); mf->objects[i].file_info_indexes = x_calloc(mf->objects[i].n_file_info_indexes, sizeof(*mf->objects[i].file_info_indexes)); for (uint32_t j = 0; j < mf->objects[i].n_file_info_indexes; j++) { READ_INT(4, mf->objects[i].file_info_indexes[j]); } READ_BYTES(mf->hash_size, mf->objects[i].hash.hash); READ_INT(4, mf->objects[i].hash.size); } return mf; error: cc_log("Corrupt manifest file"); free_manifest(mf); return NULL; }