SceneTreeItemParticleInnerEmmiter::SceneTreeItemParticleInnerEmmiter(DAVA::ParticleLayer *_parent, DAVA::ParticleEmitter *_emitter)
: SceneTreeItem(SceneTreeItem::EIT_InnerEmmiter)
, parent(_parent)
, emitter(_emitter)
{
DoSync(this, emitter);
}
void Ctrl::Sync(const Rect& sr)
{
GuiLock __;
LLOG("Sync " << Name() << " " << sr);
DoSync(this, sr, true);
SyncCaret();
}
/**
* DoRestore
*/
static bool DoRestore() {
Common::InSaveFile *f = _vm->getSaveFileMan()->openForLoading(g_savedFiles[g_RestoreGameNumber].name);
if (f == NULL) {
return false;
}
Common::Serializer s(f, 0);
SaveGameHeader hdr;
if (!syncSaveGameHeader(s, hdr)) {
delete f; // Invalid header, or savegame too new -> skip it
return false;
}
DoSync(s);
uint32 id = f->readSint32LE();
if (id != (uint32)0xFEEDFACE)
error("Incompatible saved game");
bool failed = (f->eos() || f->err());
delete f;
if (failed) {
GUI::MessageDialog dialog(_("Failed to load game state from file."));
dialog.runModal();
}
return !failed;
}
Common::Error saveSavegameData(int saveGameIdx, const Common::String &saveName) {
const char *filename = _vm->getSavegameFile(saveGameIdx);
Common::SaveFileManager *saveMan = g_system->getSavefileManager();
Common::OutSaveFile *f = saveMan->openForSaving(filename);
if (f == NULL)
return Common::kNoGameDataFoundError;
// Save the savegame header
CruiseSavegameHeader header;
header.saveName = saveName;
writeSavegameHeader(f, header);
if (f->err()) {
delete f;
saveMan->removeSavefile(filename);
return Common::kWritingFailed;
} else {
// Create the remainder of the savegame
Common::Serializer s(NULL, f);
DoSync(s);
f->finalize();
delete f;
return Common::kNoError;
}
}
static void TB_OnClick(HWND hWnd, DWORD dwID)
{
HHInfo *info = (HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
switch (dwID)
{
case IDTB_STOP:
DoPageAction(info, WB_STOP);
break;
case IDTB_REFRESH:
DoPageAction(info, WB_REFRESH);
break;
case IDTB_BACK:
DoPageAction(info, WB_GOBACK);
break;
case IDTB_HOME:
NavigateToChm(info, info->pCHMInfo->szFile, info->WinType.pszHome);
break;
case IDTB_FORWARD:
DoPageAction(info, WB_GOFORWARD);
break;
case IDTB_PRINT:
DoPageAction(info, WB_PRINT);
break;
case IDTB_EXPAND:
case IDTB_CONTRACT:
ExpandContract(info);
break;
case IDTB_SYNC:
DoSync(info);
break;
case IDTB_OPTIONS:
DisplayPopupMenu(info);
break;
case IDTB_NOTES:
case IDTB_CONTENTS:
case IDTB_INDEX:
case IDTB_SEARCH:
case IDTB_HISTORY:
case IDTB_FAVORITES:
/* These are officially unimplemented as of the Windows 7 SDK */
break;
case IDTB_BROWSE_FWD:
case IDTB_BROWSE_BACK:
case IDTB_JUMP1:
case IDTB_JUMP2:
case IDTB_CUSTOMIZE:
case IDTB_ZOOM:
case IDTB_TOC_NEXT:
case IDTB_TOC_PREV:
break;
}
}
/**
* DoSave
*/
static void DoSave() {
Common::OutSaveFile *f;
const char *fname;
// Next getList() must do its stuff again
NeedLoad = true;
if (SaveSceneName == NULL)
SaveSceneName = NewName();
if (SaveSceneDesc[0] == 0)
SaveSceneDesc = "unnamed";
fname = SaveSceneName;
f = _vm->getSaveFileMan()->openForSaving(fname);
Common::Serializer s(0, f);
if (f == NULL)
goto save_failure;
// Write out a savegame header
SaveGameHeader hdr;
hdr.id = SAVEGAME_ID;
hdr.size = SAVEGAME_HEADER_SIZE;
hdr.ver = CURRENT_VER;
memcpy(hdr.desc, SaveSceneDesc, SG_DESC_LEN);
hdr.desc[SG_DESC_LEN - 1] = 0;
g_system->getTimeAndDate(hdr.dateTime);
if (!syncSaveGameHeader(s, hdr) || f->err()) {
goto save_failure;
}
DoSync(s);
// Write out the special Id for Discworld savegames
f->writeUint32LE(0xFEEDFACE);
if (f->err())
goto save_failure;
f->finalize();
delete f;
return;
save_failure:
if (f) {
delete f;
_vm->getSaveFileMan()->removeSavefile(fname);
}
GUI::MessageDialog dialog("Failed to save game state to file.");
dialog.runModal();
}
void Ctrl::Sync()
{
GuiLock __;
LLOG("Sync " << Name());
if(top && IsOpen()) {
LLOG("Sync UpdateWindow " << Name());
SyncScroll();
WndUpdate();
}
else
if(parent)
DoSync(parent, GetRect(), inframe);
SyncCaret();
}
/**
* DoRestore
*/
static bool DoRestore() {
Common::InSaveFile *f = _vm->getSaveFileMan()->openForLoading(g_savedFiles[g_RestoreGameNumber].name);
if (f == NULL) {
return false;
}
Common::Serializer s(f, 0);
SaveGameHeader hdr;
if (!syncSaveGameHeader(s, hdr)) {
delete f; // Invalid header, or savegame too new -> skip it
return false;
}
// Load in the data. For older savegame versions, we potentially need to load the data twice, once
// for pre 1.5 savegames, and if that fails, a second time for 1.5 savegames
int numInterpreters = hdr.numInterpreters;
int32 currentPos = f->pos();
for (int tryNumber = 0; tryNumber < ((hdr.ver >= 2) ? 1 : 2); ++tryNumber) {
// If it's the second loop iteration, try with the 1.5 savegame number of interpreter contexts
if (tryNumber == 1) {
f->seek(currentPos);
numInterpreters = 80;
}
// Load the savegame data
if (DoSync(s, numInterpreters))
// Data load was successful (or likely), so break out of loop
break;
}
uint32 id = f->readSint32LE();
if (id != (uint32)0xFEEDFACE)
error("Incompatible saved game");
bool failed = (f->eos() || f->err());
delete f;
if (failed) {
GUI::MessageDialog dialog(_("Failed to load game state from file."));
dialog.runModal();
}
return !failed;
}
SceneTreeItemParticleLayer::SceneTreeItemParticleLayer(DAVA::ParticleEmitter* _parent, DAVA::ParticleLayer *_layer)
: SceneTreeItem(SceneTreeItem::EIT_Layer)
, parent(_parent)
, layer(_layer)
, hasInnerEmmiter(false)
{
if(NULL != layer)
{
setCheckable(true);
if(layer->GetDisabled())
{
setCheckState(Qt::Unchecked);
}
else
{
setCheckState(Qt::Checked);
}
hasInnerEmmiter = (layer->GetInnerEmitter()!=NULL);
}
DoSync(this, layer);
}
SceneTreeItemEntity::SceneTreeItemEntity(DAVA::Entity* _entity)
: SceneTreeItem(SceneTreeItem::EIT_Entity)
, entity(_entity)
{
DoSync(this, entity);
}
void SceneTreeItemEntity::DoSync(QStandardItem *rootItem, DAVA::Entity *entity)
{
if(NULL != rootItem && NULL != entity)
{
DAVA::int32 i;
QSet<DAVA::Entity *> entitiesSet;
QSet<DAVA::ParticleLayer *> layersSet;
DAVA::ParticleEmitter *emitter = DAVA::GetEmitter(entity);
DAVA::Vector<DAVA::ParticleLayer*> *emitterLayers = NULL;
// remember all entity childs
for(i = 0; i < entity->GetChildrenCount(); ++i)
{
entitiesSet.insert(entity->GetChild(i));
}
// remember all particle layers
if(NULL != emitter)
{
emitterLayers = &emitter->GetLayers();
for(size_t i = 0; i < emitterLayers->size(); ++i)
{
layersSet.insert(emitterLayers->operator[](i));
}
}
// remove items that are not in set
for(int i = 0; i < rootItem->rowCount(); ++i)
{
bool doRemove = true;
SceneTreeItem *childItem = (SceneTreeItem *) rootItem->child(i);
if(childItem->ItemType() == SceneTreeItem::EIT_Entity)
{
SceneTreeItemEntity *entityItem = (SceneTreeItemEntity *) childItem;
if(entitiesSet.contains(entityItem->entity))
{
doRemove = false;
}
}
else if(childItem->ItemType() == SceneTreeItem::EIT_Layer)
{
SceneTreeItemParticleLayer *layerItem = (SceneTreeItemParticleLayer *) childItem;
if(layersSet.contains(layerItem->layer))
{
doRemove = false;
}
}
if(doRemove)
{
rootItem->removeRow(i);
i--;
}
}
entitiesSet.clear();
layersSet.clear();
// add entities
int row = 0;
for(int i = 0; i < entity->GetChildrenCount(); ++i)
{
bool repeatStep;
DAVA::Entity *childEntity = entity->GetChild(i);
do
{
SceneTreeItem *item = (SceneTreeItem *) rootItem->child(row);
DAVA::Entity *itemEntity = SceneTreeItemEntity::GetEntity(item);
repeatStep = false;
// remove items that we already add
while(entitiesSet.contains(itemEntity))
{
rootItem->removeRow(row);
item = (SceneTreeItem *) rootItem->child(row);
itemEntity = SceneTreeItemEntity::GetEntity(item);
}
// append entity that isn't in child items list
if(NULL == item)
{
rootItem->appendRow(new SceneTreeItemEntity(childEntity));
}
else if(childEntity != itemEntity)
{
// now we should decide what to do: remove item or insert it
// calc len until itemEntity will be found in real entity childs
int lenUntilRealEntity = 0;
for(int j = i; j < entity->GetChildrenCount(); ++j)
{
if(entity->GetChild(j) == itemEntity)
{
lenUntilRealEntity = j - i;
break;
}
}
// calc len until current real entity child will be found in current item childs
int lenUntilItem = 0;
for(int j = i; j < rootItem->rowCount(); ++j)
{
SceneTreeItem *itm = (SceneTreeItem *) rootItem->child(j);
DAVA::Entity *itmEn = SceneTreeItemEntity::GetEntity(itm);
if(childEntity == itmEn)
{
lenUntilItem = j - i;
break;
}
}
if(lenUntilRealEntity >= lenUntilItem)
{
rootItem->removeRow(row);
repeatStep = true;
}
else
{
rootItem->insertRow(row, new SceneTreeItemEntity(childEntity));
}
}
else
{
DoSync(item, itemEntity);
}
}
while(repeatStep);
// remember that we add that entity
entitiesSet.insert(childEntity);
row++;
}
// add layers
if(NULL != emitterLayers)
{
for(size_t i = 0; i < emitterLayers->size(); ++i)
{
bool repeatStep;
DAVA::ParticleLayer* childLayer = emitterLayers->operator[](i);
do
{
SceneTreeItem *item = (SceneTreeItem *) rootItem->child(row);
DAVA::ParticleLayer *itemLayer = SceneTreeItemParticleLayer::GetLayer(item);
repeatStep = false;
// remove items that we already add
while(layersSet.contains(itemLayer))
{
rootItem->removeRow(row);
SceneTreeItem *item = (SceneTreeItem *) rootItem->child(row);
DAVA::ParticleLayer *itemLayer = SceneTreeItemParticleLayer::GetLayer(item);
}
if(NULL == item)
{
rootItem->appendRow(new SceneTreeItemParticleLayer(emitter, childLayer));
}
else if(childLayer != itemLayer)
{
// now we should decide what to do: remove layer or insert it
// calc len until itemEntity will be found in real
int lenUntilRealLayer = 0;
for(int j = i; j < (int) emitterLayers->size(); ++j)
{
if(emitterLayers->operator[](j) == itemLayer)
{
lenUntilRealLayer = j - i;
break;
}
}
// calc len until current real entity child will be found in current item childs
int lenUntilItem = 0;
for(int j = i; j < rootItem->rowCount(); ++j)
{
SceneTreeItem *itm = (SceneTreeItem *) rootItem->child(j);
DAVA::ParticleLayer *itmLay = SceneTreeItemParticleLayer::GetLayer(itm);
if(childLayer == itmLay)
{
lenUntilItem = j - i;
break;
}
}
if(lenUntilRealLayer >= lenUntilItem)
{
rootItem->removeRow(row);
repeatStep = true;
}
else
{
rootItem->insertRow(row, new SceneTreeItemParticleLayer(emitter, childLayer));
}
}
else
{
SceneTreeItemParticleLayer::DoSync(item, itemLayer);
}
} while (repeatStep);
row++;
layersSet.insert(childLayer);
}
}
// remove all other rows
if(row < rootItem->rowCount())
{
rootItem->removeRows(row, rootItem->rowCount() - row);
}
}
}
/**
* DoSave
*/
static void DoSave() {
Common::OutSaveFile *f;
char tmpName[FNAMELEN];
// Next getList() must do its stuff again
g_NeedLoad = true;
if (g_SaveSceneName == NULL) {
// Generate a new unique save name
int i;
int ano = 1; // Allocated number
while (1) {
Common::String fname = _vm->getSavegameFilename(ano);
strcpy(tmpName, fname.c_str());
for (i = 0; i < g_numSfiles; i++)
if (!strcmp(g_savedFiles[i].name, tmpName))
break;
if (i == g_numSfiles)
break;
ano++;
}
g_SaveSceneName = tmpName;
}
if (g_SaveSceneDesc[0] == 0)
g_SaveSceneDesc = "unnamed";
f = _vm->getSaveFileMan()->openForSaving(g_SaveSceneName);
Common::Serializer s(0, f);
if (f == NULL) {
SaveFailure(f);
return;
}
// Write out a savegame header
SaveGameHeader hdr;
hdr.id = SAVEGAME_ID;
hdr.size = SAVEGAME_HEADER_SIZE;
hdr.ver = CURRENT_VER;
memcpy(hdr.desc, g_SaveSceneDesc, SG_DESC_LEN);
hdr.desc[SG_DESC_LEN - 1] = 0;
g_system->getTimeAndDate(hdr.dateTime);
hdr.scnFlag = _vm->getFeatures() & GF_SCNFILES;
hdr.language = _vm->_config->_language;
if (!syncSaveGameHeader(s, hdr) || f->err()) {
SaveFailure(f);
return;
}
DoSync(s, hdr.numInterpreters);
// Write out the special Id for Discworld savegames
f->writeUint32LE(0xFEEDFACE);
if (f->err()) {
SaveFailure(f);
return;
}
f->finalize();
delete f;
g_SaveSceneName = NULL; // Invalidate save name
}
Common::Error loadSavegameData(int saveGameIdx) {
int lowMemorySave;
Common::String saveName;
cellStruct *currentcellHead;
Common::SaveFileManager *saveMan = g_system->getSavefileManager();
Common::InSaveFile *f = saveMan->openForLoading(_vm->getSavegameFile(saveGameIdx));
if (f == NULL) {
printInfoBlackBox("Savegame not found...");
waitForPlayerInput();
return Common::kNoGameDataFoundError;
}
printInfoBlackBox("Loading in progress...");
initVars();
_vm->sound().stopMusic();
// Skip over the savegame header
CruiseSavegameHeader header;
readSavegameHeader(f, header);
delete header.thumbnail;
// Synchronise the remaining data of the savegame
Common::Serializer s(f, NULL);
DoSync(s);
delete f;
// Post processing
for (int j = 0; j < 64; j++)
preloadData[j].ptr = NULL;
for (int j = 1; j < numOfLoadedOverlay; j++) {
if (overlayTable[j].alreadyLoaded) {
overlayTable[j].alreadyLoaded = 0;
loadOverlay(overlayTable[j].overlayName);
if (overlayTable[j].alreadyLoaded) {
ovlDataStruct *ovlData = overlayTable[j].ovlData;
// overlay BSS
if (ovlRestoreData[j]._sBssSize) {
if (ovlData->data4Ptr) {
MemFree(ovlData->data4Ptr);
}
ovlData->data4Ptr = ovlRestoreData[j]._pBss;
ovlData->sizeOfData4 = ovlRestoreData[j]._sBssSize;
}
// overlay object data
if (ovlRestoreData[j]._sNumObj) {
if (ovlData->arrayObjVar) {
MemFree(ovlData->arrayObjVar);
}
ovlData->arrayObjVar = ovlRestoreData[j]._pObj;
ovlData->size9 = ovlRestoreData[j]._sNumObj;
}
}
}
}
updateAllScriptsImports();
lastAni[0] = 0;
lowMemorySave = lowMemory;
for (int i = 0; i < NUM_FILE_ENTRIES; i++) {
if (filesDatabase[i].subData.ptr) {
int j;
int k;
for (j = i + 1; j < NUM_FILE_ENTRIES && filesDatabase[j].subData.ptr && !strcmp(filesDatabase[i].subData.name, filesDatabase[j].subData.name) && (filesDatabase[j].subData.index == (j - i)); j++)
;
for (k = i; k < j; k++) {
if (filesDatabase[k].subData.ptrMask)
lowMemory = 0;
filesDatabase[k].subData.ptr = NULL;
filesDatabase[k].subData.ptrMask = NULL;
}
/*if (j < 2) {
error("Unsupported mono file load");
//loadFileMode1(filesDatabase[j].subData.name,filesDatabase[j].subData.var4);
} else */
if (strlen(filesDatabase[i].subData.name) > 0) {
loadFileRange(filesDatabase[i].subData.name, filesDatabase[i].subData.index, i, j - i);
} else {
filesDatabase[i].subData.ptr = NULL;
filesDatabase[i].subData.ptrMask = NULL;
}
i = j - 1;
lowMemory = lowMemorySave;
}
}
lastAni[0] = 0;
currentcellHead = cellHead.next;
while (currentcellHead) {
if (currentcellHead->type == 5) {
uint8 *ptr = mainProc14(currentcellHead->overlay, currentcellHead->idx);
ASSERT(0);
if (ptr) {
ASSERT(0);
//*(int16 *)(currentcellHead->datas+0x2E) = getSprite(ptr,*(int16 *)(currentcellHead->datas+0xE));
} else {
ASSERT(0);
//*(int16 *)(currentcellHead->datas+0x2E) = 0;
}
}
currentcellHead = currentcellHead->next;
}
if (strlen(currentCtpName)) {
loadCtFromSave = 1;
initCt(currentCtpName);
loadCtFromSave = 0;
}
//prepareFadeOut();
//gfxModuleData.gfxFunction8();
for (int j = 0; j < 8; j++) {
if (strlen((char *)backgroundTable[j].name)) {
loadBackground(backgroundTable[j].name, j);
}
}
regenerateBackgroundIncrust(&backgroundIncrustHead);
// to finish
changeCursor(CURSOR_NORMAL);
mainDraw(1);
flipScreen();
return Common::kNoError;
}
/**
* DoSave
*/
static void DoSave() {
Common::OutSaveFile *f;
char tmpName[FNAMELEN];
// Next getList() must do its stuff again
NeedLoad = true;
if (SaveSceneName == NULL) {
// Generate a new unique save name
int i;
int ano = 1; // Allocated number
while (1) {
Common::String fname = _vm->getSavegameFilename(ano);
strcpy(tmpName, fname.c_str());
for (i = 0; i < numSfiles; i++)
if (!strcmp(savedFiles[i].name, tmpName))
break;
if (i == numSfiles)
break;
ano++;
}
SaveSceneName = tmpName;
}
if (SaveSceneDesc[0] == 0)
SaveSceneDesc = "unnamed";
f = _vm->getSaveFileMan()->openForSaving(SaveSceneName);
Common::Serializer s(0, f);
if (f == NULL)
goto save_failure;
// Write out a savegame header
SaveGameHeader hdr;
hdr.id = SAVEGAME_ID;
hdr.size = SAVEGAME_HEADER_SIZE;
hdr.ver = CURRENT_VER;
memcpy(hdr.desc, SaveSceneDesc, SG_DESC_LEN);
hdr.desc[SG_DESC_LEN - 1] = 0;
g_system->getTimeAndDate(hdr.dateTime);
if (!syncSaveGameHeader(s, hdr) || f->err()) {
goto save_failure;
}
DoSync(s);
// Write out the special Id for Discworld savegames
f->writeUint32LE(0xFEEDFACE);
if (f->err())
goto save_failure;
f->finalize();
delete f;
SaveSceneName = NULL; // Invalidate save name
return;
save_failure:
if (f) {
delete f;
_vm->getSaveFileMan()->removeSavefile(SaveSceneName);
SaveSceneName = NULL; // Invalidate save name
}
GUI::MessageDialog dialog("Failed to save game state to file.");
dialog.runModal();
}
void Via::Sync(cycles_t cycles) {
DoSync(cycles, *m_syncContext.input, *m_syncContext.renderContext, *m_syncContext.audioContext);
}
