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;
}
