Example #1
0
static void syncBackgroundTable(Common::Serializer &s) {
	// restore backgroundTable
	for (int i = 0; i < 8; i++) {
		if (s.isSaving() && (strlen(backgroundTable[i].name) > 8))
			warning("Saving a background resource that has too long a name");

		s.syncBytes((byte *)backgroundTable[i].name, 9);
		s.syncBytes((byte *)backgroundTable[i].extention, 6);
	}
}
Example #2
0
static bool syncSaveGameHeader(Common::Serializer &s, SaveGameHeader &hdr) {
	s.syncAsUint32LE(hdr.id);
	s.syncAsUint32LE(hdr.size);
	s.syncAsUint32LE(hdr.ver);

	s.syncBytes((byte *)hdr.desc, SG_DESC_LEN);
	hdr.desc[SG_DESC_LEN - 1] = 0;

	syncTime(s, hdr.dateTime);

	int tmp = hdr.size - s.bytesSynced();

	// NOTE: We can't use SAVEGAME_ID here when attempting to remove a saved game from the launcher,
	// as there is no TinselEngine initialized then. This means that we can't check if this is a DW1
	// or DW2 savegame in this case, but it doesn't really matter, as the saved game is about to be
	// deleted anyway. Refer to bug #3387551.
	bool correctID = _vm ? (hdr.id == SAVEGAME_ID) : (hdr.id == DW1_SAVEGAME_ID || hdr.id == DW2_SAVEGAME_ID);

	// Perform sanity check
	if (tmp < 0 || !correctID || hdr.ver > CURRENT_VER || hdr.size > 1024)
		return false;
	// Skip over any extra bytes
	s.skip(tmp);
	return true;
}
Example #3
0
static void DoSync(Common::Serializer &s) {
	syncBasicInfo(s);
	_vm->sound().doSync(s);

	syncPalette(s, newPal);
	syncPalette(s, workpal);

	s.syncBytes((byte *)currentCtpName, 40);

	syncBackgroundTable(s);
	syncPalScreen(s);
	syncSoundList(s);

	for (int i = 0; i < stateID; ++i)
		s.syncAsSint16LE(globalVars[i]);

	syncFilesDatabase(s);
	syncOverlays1(s);
	syncPreloadData(s);
	syncOverlays2(s);
	syncScript(s, &procHead);
	syncScript(s, &relHead);
	syncCell(s);
	syncIncrust(s);
	syncActors(s);
	syncSongs(s);
	syncCT(s);
}
Example #4
0
static void syncSavedData(Common::Serializer &s, SAVED_DATA &sd, int numInterp) {
	s.syncAsUint32LE(sd.SavedSceneHandle);
	s.syncAsUint32LE(sd.SavedBgroundHandle);
	for (int i = 0; i < MAX_MOVERS; ++i)
		syncSavedMover(s, sd.SavedMoverInfo[i]);
	for (int i = 0; i < MAX_SAVED_ACTORS; ++i)
		syncSavedActor(s, sd.SavedActorInfo[i]);

	s.syncAsSint32LE(sd.NumSavedActors);
	s.syncAsSint32LE(sd.SavedLoffset);
	s.syncAsSint32LE(sd.SavedToffset);
	for (int i = 0; i < numInterp; ++i)
		sd.SavedICInfo[i].syncWithSerializer(s);
	for (int i = 0; i < MAX_POLY; ++i)
		s.syncAsUint32LE(sd.SavedDeadPolys[i]);
	s.syncAsUint32LE(sd.SavedControl);
	s.syncAsUint32LE(sd.SavedMidi);
	s.syncAsUint32LE(sd.SavedLoop);
	s.syncAsUint32LE(sd.SavedNoBlocking);

	// SavedNoScrollData
	for (int i = 0; i < MAX_VNOSCROLL; ++i)
		syncNoScrollB(s, sd.SavedNoScrollData.NoVScroll[i]);
	for (int i = 0; i < MAX_HNOSCROLL; ++i)
		syncNoScrollB(s, sd.SavedNoScrollData.NoHScroll[i]);
	s.syncAsUint32LE(sd.SavedNoScrollData.NumNoV);
	s.syncAsUint32LE(sd.SavedNoScrollData.NumNoH);

	// Tinsel 2 fields
	if (TinselV2) {
		// SavedNoScrollData
		s.syncAsUint32LE(sd.SavedNoScrollData.xTrigger);
		s.syncAsUint32LE(sd.SavedNoScrollData.xDistance);
		s.syncAsUint32LE(sd.SavedNoScrollData.xSpeed);
		s.syncAsUint32LE(sd.SavedNoScrollData.yTriggerTop);
		s.syncAsUint32LE(sd.SavedNoScrollData.yTriggerBottom);
		s.syncAsUint32LE(sd.SavedNoScrollData.yDistance);
		s.syncAsUint32LE(sd.SavedNoScrollData.ySpeed);

		for (int i = 0; i < NUM_ZPOSITIONS; ++i)
			syncZPosition(s, sd.zPositions[i]);
		s.syncBytes(sd.savedActorZ, MAX_SAVED_ACTOR_Z);
		for (int i = 0; i < MAX_POLY; ++i)
			syncPolyVolatile(s, sd.SavedPolygonStuff[i]);
		for (int i = 0; i < 3; ++i)
			s.syncAsUint32LE(sd.SavedTune[i]);
		s.syncAsByte(sd.bTinselDim);
		s.syncAsSint32LE(sd.SavedScrollFocus);
		for (int i = 0; i < SV_TOPVALID; ++i)
			s.syncAsSint32LE(sd.SavedSystemVars[i]);
		for (int i = 0; i < MAX_SOUNDREELS; ++i)
			syncSoundReel(s, sd.SavedSoundReels[i]);
	}
}
Example #5
0
void syncScript(Common::Serializer &s, scriptInstanceStruct *entry) {
	int numScripts = 0;
	uint32 dummyLong = 0;
	uint16 dummyWord = 0;

	if (s.isSaving()) {
		// Figure out the number of scripts to save
		scriptInstanceStruct* pCurrent = entry->nextScriptPtr;
		while (pCurrent) {
			++numScripts;
			pCurrent = pCurrent->nextScriptPtr;
		}
	}
	s.syncAsSint16LE(numScripts);

	scriptInstanceStruct *ptr = entry->nextScriptPtr;
	for (int i = 0; i < numScripts; ++i) {
		if (s.isLoading())
			ptr = (scriptInstanceStruct *)mallocAndZero(sizeof(scriptInstanceStruct));

		s.syncAsUint16LE(dummyWord);
		s.syncAsSint16LE(ptr->ccr);
		s.syncAsSint16LE(ptr->scriptOffset);
		s.syncAsUint32LE(dummyLong);
		s.syncAsSint16LE(ptr->dataSize);
		s.syncAsSint16LE(ptr->scriptNumber);
		s.syncAsSint16LE(ptr->overlayNumber);
		s.syncAsSint16LE(ptr->sysKey);
		s.syncAsSint16LE(ptr->freeze);
		s.syncAsSint16LE(ptr->type);
		s.syncAsSint16LE(ptr->var16);
		s.syncAsSint16LE(ptr->var18);
		s.syncAsSint16LE(ptr->var1A);

		s.syncAsSint16LE(ptr->dataSize);

		if (ptr->dataSize) {
			if (s.isLoading())
				ptr->data = (byte *)mallocAndZero(ptr->dataSize);
			s.syncBytes(ptr->data, ptr->dataSize);
		}

		if (s.isLoading()) {
			ptr->nextScriptPtr = NULL;
			entry->nextScriptPtr = ptr;
			entry = ptr;
		} else {
			ptr = ptr->nextScriptPtr;
		}
	}
}
Example #6
0
static bool syncSaveGameHeader(Common::Serializer &s, SaveGameHeader &hdr) {
	s.syncAsUint32LE(hdr.id);
	s.syncAsUint32LE(hdr.size);
	s.syncAsUint32LE(hdr.ver);

	s.syncBytes((byte *)hdr.desc, SG_DESC_LEN);
	hdr.desc[SG_DESC_LEN - 1] = 0;

	syncTime(s, hdr.dateTime);

	int tmp = hdr.size - s.bytesSynced();

	// NOTE: We can't use SAVEGAME_ID here when attempting to remove a saved game from the launcher,
	// as there is no TinselEngine initialized then. This means that we can't check if this is a DW1
	// or DW2 savegame in this case, but it doesn't really matter, as the saved game is about to be
	// deleted anyway. Refer to bug #3387551.
	bool correctID = _vm ? (hdr.id == SAVEGAME_ID) : (hdr.id == DW1_SAVEGAME_ID || hdr.id == DW2_SAVEGAME_ID);

	// Perform sanity check
	if (tmp < 0 || !correctID || hdr.ver > CURRENT_VER || hdr.size > 1024)
		return false;

	if (tmp > 0) {
		// If there's header space left, handling syncing the Scn flag and game language
		s.syncAsByte(hdr.scnFlag);
		s.syncAsByte(hdr.language);
		tmp -= 2;

		if (_vm && s.isLoading()) {
			// If the engine is loaded, ensure the Scn/Gra usage is correct, and it's the correct language
			if ((hdr.scnFlag != ((_vm->getFeatures() & GF_SCNFILES) != 0)) ||
					(hdr.language != _vm->_config->_language))
				return false;
		}
	}

	// Handle the number of interpreter contexts that will be saved in the savegame
	if (tmp >= 2) {
		tmp -= 2;
		hdr.numInterpreters = NUM_INTERPRET;
		s.syncAsUint16LE(hdr.numInterpreters);
	} else {
		hdr.numInterpreters = (TinselV2 ? 70 : 64) - 20;
	}

	// Skip over any extra bytes
	s.skip(tmp);
	return true;
}
Example #7
0
static void syncSongs(Common::Serializer &s) {
	int size = 0;

	if (songLoaded) {
		// TODO: implement
		s.syncAsByte(size);
		if (s.isLoading()) {
			saveVar1 = size;
			if (saveVar1)
				s.syncBytes(saveVar2, saveVar1);
		}
	} else {
		s.syncAsByte(size);
	}
}
Example #8
0
static void syncPreloadData(Common::Serializer &s) {
	uint8 dummyByte = 0;
	uint32 dummyLong = 0;

	for (int i = 0; i < 64; i++) {
		preloadStruct &pe = preloadData[i];

		s.syncBytes((byte *)pe.name, 15);
		s.syncAsByte(dummyByte);
		s.syncAsUint32LE(pe.size);
		s.syncAsUint32LE(pe.sourceSize);
		s.syncAsUint32LE(dummyLong);
		s.syncAsUint16LE(pe.nofree);
		s.syncAsUint16LE(pe.protect);
		s.syncAsUint16LE(pe.ovl);
	}
}
Example #9
0
static bool syncSaveGameHeader(Common::Serializer &s, SaveGameHeader &hdr) {
	s.syncAsUint32LE(hdr.id);
	s.syncAsUint32LE(hdr.size);
	s.syncAsUint32LE(hdr.ver);

	s.syncBytes((byte *)hdr.desc, SG_DESC_LEN);
	hdr.desc[SG_DESC_LEN - 1] = 0;

	syncTime(s, hdr.dateTime);

	int tmp = hdr.size - s.bytesSynced();
	// Perform sanity check
	if (tmp < 0 || hdr.id != SAVEGAME_ID || hdr.ver > CURRENT_VER || hdr.size > 1024)
		return false;
	// Skip over any extra bytes
	s.skip(tmp);
	return true;
}
Example #10
0
void CGEEngine::syncHeader(Common::Serializer &s) {
	debugC(1, kCGEDebugEngine, "CGEEngine::syncHeader(s)");

	int i = kDemo;

	s.syncAsUint16LE(_now);
	s.syncAsUint16LE(_oldLev);
	s.syncAsUint16LE(i);        // unused Demo string id
	for (i = 0; i < 5; i++)
		s.syncAsUint16LE(_game);
	s.syncAsSint16LE(i);		// unused VGA::Mono variable
	s.syncAsUint16LE(_music);
	s.syncBytes(_volume, 2);
	for (i = 0; i < 4; i++)
		s.syncAsUint16LE(_flag[i]);

	if (s.isLoading()) {
		// Reset scene values
		initSceneValues();
	}

	for (i = 0; i < kSceneMax; i++) {
		s.syncAsSint16LE(_heroXY[i].x);
		s.syncAsUint16LE(_heroXY[i].y);
	}
	for (i = 0; i < 1 + kSceneMax; i++) {
		s.syncAsByte(_barriers[i]._horz);
		s.syncAsByte(_barriers[i]._vert);
	}
	for (i = 0; i < kPocketNX; i++)
		s.syncAsUint16LE(_pocref[i]);

	if (s.isSaving()) {
		// Write checksum
		int checksum = kSavegameCheckSum;
		s.syncAsUint16LE(checksum);
	} else {
		// Read checksum and validate it
		uint16 checksum = 0;
		s.syncAsUint16LE(checksum);
		if (checksum != kSavegameCheckSum)
			error("%s", _text->getText(kBadSVG));
	}
}
Example #11
0
static void syncOverlays1(Common::Serializer &s) {
	uint8 dummyByte = 0;
	uint32 dummyLong = 0;

	for (int i = 0; i < numOfLoadedOverlay; i++) {
		overlayStruct &oe = overlayTable[i];

		s.syncBytes((byte *)oe.overlayName, 13);
		s.syncAsByte(dummyByte);
		s.syncAsUint32LE(dummyLong);
		s.syncAsUint16LE(oe.alreadyLoaded);
		s.syncAsUint16LE(oe.state);
		s.syncAsUint32LE(dummyLong);
		s.syncAsUint32LE(dummyLong);
		s.syncAsUint32LE(dummyLong);
		s.syncAsUint32LE(dummyLong);
		s.syncAsUint16LE(oe.executeScripts);
	}
}
Example #12
0
void SaveLoadManager::syncSavegameData(Common::Serializer &s, int version) {
	// The brief version 3 had the highscores embedded. They're in a separate file now, so skip
	if (version == 3 && s.isLoading())
		s.skip(100);

	s.syncBytes(&_vm->_globals->_saveData->_data[0], 2050);
	syncCharacterLocation(s, _vm->_globals->_saveData->_cloneHopkins);
	syncCharacterLocation(s, _vm->_globals->_saveData->_realHopkins);
	syncCharacterLocation(s, _vm->_globals->_saveData->_samantha);

	for (int i = 0; i < 35; ++i)
		s.syncAsSint16LE(_vm->_globals->_saveData->_inventory[i]);

	if (version > 1) {
		s.syncAsSint16LE(_vm->_globals->_saveData->_mapCarPosX);
		s.syncAsSint16LE(_vm->_globals->_saveData->_mapCarPosY);
	} else {
		_vm->_globals->_saveData->_mapCarPosX = _vm->_globals->_saveData->_mapCarPosY = 0;
	}

}
Example #13
0
static void syncFilesDatabase(Common::Serializer &s) {
	uint8 dummyVal = 0;
	uint32 tmp;

	for (int i = 0; i < NUM_FILE_ENTRIES; i++) {
		dataFileEntry &fe = filesDatabase[i];

		s.syncAsUint16LE(fe.widthInColumn);
		s.syncAsUint16LE(fe.width);
		s.syncAsUint16LE(fe.resType);
		s.syncAsUint16LE(fe.height);

		// Remember whether this file database was open or not.
		// Upon loading, loadSavegameData uses this information
		// in order to re-open the file databases accordingly.
		tmp = (fe.subData.ptr) ? 1 : 0;
		s.syncAsUint32LE(tmp);
		if (s.isLoading()) {
			fe.subData.ptr = tmp ? (uint8 *)1 : 0;
		}

		s.syncAsSint16LE(fe.subData.index);
		s.syncBytes((byte *)fe.subData.name, 13);
		s.syncAsByte(dummyVal);

		s.syncAsSint16LE(fe.subData.transparency);

		// Treat fe.subData.ptrMask the same as fe.subData.ptr.
		tmp = (fe.subData.ptrMask) ? 1 : 0;
		s.syncAsUint32LE(tmp);
		if (s.isLoading()) {
			fe.subData.ptrMask = tmp ? (uint8 *)1 : 0;
		}

		s.syncAsUint16LE(fe.subData.resourceType);
		s.syncAsSint16LE(fe.subData.compression);
	}
}
Example #14
0
static void syncFilesDatabase(Common::Serializer &s) {
	uint8 dummyVal = 0;
	uint32 tmp;

	for (int i = 0; i < NUM_FILE_ENTRIES; i++) {
		dataFileEntry &fe = filesDatabase[i];

		s.syncAsUint16LE(fe.widthInColumn);
		s.syncAsUint16LE(fe.width);
		s.syncAsUint16LE(fe.resType);
		s.syncAsUint16LE(fe.height);

		// TODO: Have a look at the saving/loading of this pointer
		tmp = (fe.subData.ptr) ? 1 : 0;
		s.syncAsUint32LE(tmp);
		if (s.isLoading()) {
			fe.subData.ptr = (uint8 *)tmp;
		}

		s.syncAsSint16LE(fe.subData.index);
		s.syncBytes((byte *)fe.subData.name, 13);
		s.syncAsByte(dummyVal);

		s.syncAsSint16LE(fe.subData.transparency);

		// TODO: Have a look at the saving/loading of this pointer
		tmp = (fe.subData.ptrMask) ? 1 : 0;
		s.syncAsUint32LE(tmp);
		if (s.isLoading()) {
			fe.subData.ptrMask = (uint8 *)tmp;
		}

		s.syncAsUint16LE(fe.subData.resourceType);
		s.syncAsSint16LE(fe.subData.compression);
	}
}
Example #15
0
void AvalancheEngine::synchronize(Common::Serializer &sz) {
	_animation->synchronize(sz);
	_parser->synchronize(sz);
	_nim->synchronize(sz);
	_sequence->synchronize(sz);
	_background->synchronize(sz);

	sz.syncAsByte(_carryNum);
	for (int i = 0; i < kObjectNum; i++)
		sz.syncAsByte(_objects[i]);
	sz.syncAsSint16LE(_score);
	sz.syncAsSint32LE(_money);
	sz.syncAsByte(_room);
	if (sz.isSaving())
		_saveNum++;
	sz.syncAsByte(_saveNum);
	sz.syncBytes(_roomCount, 100);
	sz.syncAsByte(_wonNim);
	sz.syncAsByte(_wineState);
	sz.syncAsByte(_cwytalotGone);
	sz.syncAsByte(_passwordNum);
	sz.syncAsByte(_aylesIsAwake);
	sz.syncAsByte(_drawbridgeOpen);
	sz.syncAsByte(_avariciusTalk);
	sz.syncAsByte(_rottenOnion);
	sz.syncAsByte(_onionInVinegar);
	sz.syncAsByte(_givenToSpludwick);
	sz.syncAsByte(_brummieStairs);
	sz.syncAsByte(_cardiffQuestionNum);
	sz.syncAsByte(_passedCwytalotInHerts);
	sz.syncAsByte(_avvyIsAwake);
	sz.syncAsByte(_avvyInBed);
	sz.syncAsByte(_userMovesAvvy);
	sz.syncAsByte(_npcFacing);
	sz.syncAsByte(_givenBadgeToIby);
	sz.syncAsByte(_friarWillTieYouUp);
	sz.syncAsByte(_tiedUp);
	sz.syncAsByte(_boxContent);
	sz.syncAsByte(_talkedToCrapulus);
	sz.syncAsByte(_jacquesState);
	sz.syncAsByte(_bellsAreRinging);
	sz.syncAsByte(_standingOnDais);
	sz.syncAsByte(_takenPen);
	sz.syncAsByte(_arrowInTheDoor);

	if (sz.isSaving()) {
		uint16 like2drinkSize = _favoriteDrink.size();
		sz.syncAsUint16LE(like2drinkSize);
		for (uint16 i = 0; i < like2drinkSize; i++) {
			char actChr = _favoriteDrink[i];
			sz.syncAsByte(actChr);
		}

		uint16 favoriteSongSize = _favoriteSong.size();
		sz.syncAsUint16LE(favoriteSongSize);
		for (uint16 i = 0; i < favoriteSongSize; i++) {
			char actChr = _favoriteSong[i];
			sz.syncAsByte(actChr);
		}

		uint16 worst_place_on_earthSize = _worstPlaceOnEarth.size();
		sz.syncAsUint16LE(worst_place_on_earthSize);
		for (uint16 i = 0; i < worst_place_on_earthSize; i++) {
			char actChr = _worstPlaceOnEarth[i];
			sz.syncAsByte(actChr);
		}

		uint16 spare_eveningSize = _spareEvening.size();
		sz.syncAsUint16LE(spare_eveningSize);
		for (uint16 i = 0; i < spare_eveningSize; i++) {
			char actChr = _spareEvening[i];
			sz.syncAsByte(actChr);
		}
	} else {
		if (!_favoriteDrink.empty())
			_favoriteDrink.clear();
		uint16 like2drinkSize = 0;
		char actChr = ' ';
		sz.syncAsUint16LE(like2drinkSize);
		for (uint16 i = 0; i < like2drinkSize; i++) {
			sz.syncAsByte(actChr);
			_favoriteDrink += actChr;
		}

		if (!_favoriteSong.empty())
			_favoriteSong.clear();
		uint16 favoriteSongSize = 0;
		sz.syncAsUint16LE(favoriteSongSize);
		for (uint16 i = 0; i < favoriteSongSize; i++) {
			sz.syncAsByte(actChr);
			_favoriteSong += actChr;
		}

		if (!_worstPlaceOnEarth.empty())
			_worstPlaceOnEarth.clear();
		uint16 worst_place_on_earthSize = 0;
		sz.syncAsUint16LE(worst_place_on_earthSize);
		for (uint16 i = 0; i < worst_place_on_earthSize; i++) {
			sz.syncAsByte(actChr);
			_worstPlaceOnEarth += actChr;
		}

		if (!_spareEvening.empty())
			_spareEvening.clear();
		uint16 spare_eveningSize = 0;
		sz.syncAsUint16LE(spare_eveningSize);
		for (uint16 i = 0; i < spare_eveningSize; i++) {
			sz.syncAsByte(actChr);
			_spareEvening += actChr;
		}
	}

	sz.syncAsSint32LE(_totalTime);
	sz.syncAsByte(_jumpStatus);
	sz.syncAsByte(_mushroomGrowing);
	sz.syncAsByte(_spludwickAtHome);
	sz.syncAsByte(_lastRoom);
	sz.syncAsByte(_lastRoomNotMap);
	sz.syncAsByte(_crapulusWillTell);
	sz.syncAsByte(_enterCatacombsFromLustiesRoom);
	sz.syncAsByte(_teetotal);
	sz.syncAsByte(_malagauche);
	sz.syncAsByte(_drinking);
	sz.syncAsByte(_enteredLustiesRoomAsMonk);
	sz.syncAsByte(_catacombX);
	sz.syncAsByte(_catacombY);
	sz.syncAsByte(_avvysInTheCupboard);
	sz.syncAsByte(_geidaFollows);
	sz.syncAsByte(_givenPotionToGeida);
	sz.syncAsByte(_lustieIsAsleep);
	sz.syncAsByte(_beenTiedUp);
	sz.syncAsByte(_sittingInPub);
	sz.syncAsByte(_spurgeTalkCount);
	sz.syncAsByte(_metAvaroid);
	sz.syncAsByte(_takenMushroom);
	sz.syncAsByte(_givenPenToAyles);
	sz.syncAsByte(_askedDogfoodAboutNim);

	for (int i = 0; i < 7; i++) {
		sz.syncAsSint32LE(_timer->_times[i]._timeLeft);
		sz.syncAsByte(_timer->_times[i]._action);
		sz.syncAsByte(_timer->_times[i]._reason);
	}

}
Example #16
0
void Sprite::sync(Common::Serializer &s) {
	uint16 unused = 0;

	s.syncAsUint16LE(unused);
	s.syncAsUint16LE(unused);	// _ext
	s.syncAsUint16LE(_ref);
	s.syncAsByte(_scene);

	// bitfield in-memory storage is unpredictable, so to avoid
	// any issues, pack/unpack everything manually
	uint16 flags = 0;
	if (s.isLoading()) {
		s.syncAsUint16LE(flags);
		_flags._hide = flags & 0x0001 ? true : false;
		_flags._near = flags & 0x0002 ? true : false;
		_flags._drag = flags & 0x0004 ? true : false;
		_flags._hold = flags & 0x0008 ? true : false;
		_flags._____ = flags & 0x0010 ? true : false;
		_flags._slav = flags & 0x0020 ? true : false;
		_flags._syst = flags & 0x0040 ? true : false;
		_flags._kill = flags & 0x0080 ? true : false;
		_flags._xlat = flags & 0x0100 ? true : false;
		_flags._port = flags & 0x0200 ? true : false;
		_flags._kept = flags & 0x0400 ? true : false;
		_flags._east = flags & 0x0800 ? true : false;
		_flags._shad = flags & 0x1000 ? true : false;
		_flags._back = flags & 0x2000 ? true : false;
		_flags._bDel = flags & 0x4000 ? true : false;
		_flags._tran = flags & 0x8000 ? true : false;
	} else {
		flags = (flags << 1) | _flags._tran;
		flags = (flags << 1) | _flags._bDel;
		flags = (flags << 1) | _flags._back;
		flags = (flags << 1) | _flags._shad;
		flags = (flags << 1) | _flags._east;
		flags = (flags << 1) | _flags._kept;
		flags = (flags << 1) | _flags._port;
		flags = (flags << 1) | _flags._xlat;
		flags = (flags << 1) | _flags._kill;
		flags = (flags << 1) | _flags._syst;
		flags = (flags << 1) | _flags._slav;
		flags = (flags << 1) | _flags._____;
		flags = (flags << 1) | _flags._hold;
		flags = (flags << 1) | _flags._drag;
		flags = (flags << 1) | _flags._near;
		flags = (flags << 1) | _flags._hide;
		s.syncAsUint16LE(flags);
	}

	s.syncAsUint16LE(_x);
	s.syncAsUint16LE(_y);
	s.syncAsByte(_z);
	s.syncAsUint16LE(_w);
	s.syncAsUint16LE(_h);
	s.syncAsUint16LE(_time);
	s.syncAsByte(_nearPtr);
	s.syncAsByte(_takePtr);
	s.syncAsSint16LE(_seqPtr);
	s.syncAsUint16LE(_shpCnt);
	s.syncBytes((byte *)&_file[0], 9);
	_file[8] = '\0';

	s.syncAsUint16LE(unused);	// _prev
	s.syncAsUint16LE(unused);	// _next
}
Example #17
0
static void syncPalette(Common::Serializer &s, uint8 *p) {
	// This is different from the original, where palette entries are 2 bytes each
	s.syncBytes(p, NBCOLORS * 3);
}
Example #18
0
static void syncIncrust(Common::Serializer &s) {
	int numEntries = 0;
	backgroundIncrustStruct *pl, *pl1;
	uint8 dummyByte = 0;
	uint16 dummyWord = 0;
	uint32 dummyLong = 0;

	if (s.isSaving()) {
		// Figure out the number of entries to save
		pl = backgroundIncrustHead.next;
		while (pl) {
			++numEntries;
			pl = pl->next;
		}
	}
	s.syncAsSint16LE(numEntries);

	pl = s.isSaving() ? backgroundIncrustHead.next : &backgroundIncrustHead;
	pl1 = &backgroundIncrustHead;

	for (int i = 0; i < numEntries; ++i) {
		backgroundIncrustStruct *t = s.isSaving() ? pl :
			(backgroundIncrustStruct *)mallocAndZero(sizeof(backgroundIncrustStruct));

		s.syncAsUint32LE(dummyLong);

		s.syncAsSint16LE(t->objectIdx);
		s.syncAsSint16LE(t->type);
		s.syncAsSint16LE(t->overlayIdx);
		s.syncAsSint16LE(t->X);
		s.syncAsSint16LE(t->Y);
		s.syncAsSint16LE(t->frame);
		s.syncAsSint16LE(t->scale);
		s.syncAsSint16LE(t->backgroundIdx);
		s.syncAsSint16LE(t->scriptNumber);
		s.syncAsSint16LE(t->scriptOverlayIdx);
		s.syncAsUint32LE(dummyLong);
		s.syncAsSint16LE(t->saveWidth);
		s.syncAsSint16LE(t->saveHeight);
		s.syncAsSint16LE(t->saveSize);
		s.syncAsSint16LE(t->savedX);
		s.syncAsSint16LE(t->savedY);
		s.syncBytes((byte *)t->name, 13);
		s.syncAsByte(dummyByte);
		s.syncAsSint16LE(t->spriteId);
		s.syncAsUint16LE(dummyWord);

		if (t->saveSize) {
			if (s.isLoading())
				t->ptr = (byte *)MemAlloc(t->saveSize);

			s.syncBytes(t->ptr, t->saveSize);
		}

		if (s.isSaving())
			pl = pl->next;
		else {
			t->next = NULL;
			pl->next = t;
			t->prev = pl1->prev;
			pl1->prev = t;
			pl = t;
		}
	}
}
Example #19
0
bool BuriedEngine::syncGlobalFlags(Common::Serializer &s, GlobalFlags &flags) {
    uint32 startBytes = s.bytesSynced();

    s.syncAsByte(flags.cgWallExploded);
    s.syncAsByte(flags.cgHookPresent);
    s.syncAsByte(flags.cgArrowPresent);
    s.syncAsByte(flags.cgHammerPresent);
    s.syncAsByte(flags.cgSmithyStatus);
    s.syncAsByte(flags.cgSmithyGuard);
    s.syncAsByte(flags.cgBaileyOneWayGuard);
    s.syncAsByte(flags.cgBaileyTwoWayGuards);
    s.syncAsByte(flags.cgTapestryFlag);
    s.syncAsByte(flags.cgBurnedLetterPresent);
    s.syncAsByte(flags.cgGoldCoinsPresent);
    s.syncAsByte(flags.cgStorageRoomVisit);
    s.syncAsByte(flags.bcTranslateEnabled);
    s.syncAsByte(flags.bcCloakingEnabled);
    s.syncAsByte(flags.bcLocateEnabled);
    s.syncAsByte(flags.myPickedUpCeramicBowl);
    s.syncAsByte(flags.myTPCodeWheelStatus);
    s.syncAsByte(flags.myTPCodeWheelLeftIndex);
    s.syncAsByte(flags.myTPCodeWheelRightIndex);
    s.syncAsByte(flags.myMCPickedUpSkull);
    s.syncAsByte(flags.myMCDeathGodOfferings);
    s.syncAsByte(flags.myWGPlacedRope);
    s.syncAsByte(flags.myWGRetrievedJadeBlock);
    s.syncAsByte(flags.myWTRetrievedLimestoneBlock);
    s.syncAsByte(flags.myWTCurrentBridgeStatus);
    s.syncAsByte(flags.myAGRetrievedEntrySkull);
    s.syncAsByte(flags.myAGRetrievedSpearSkull);
    s.syncAsByte(flags.myAGRetrievedCopperMedal);
    s.syncAsByte(flags.myAGRetrievedObsidianBlock);
    s.syncAsByte(flags.myAGHeadAStatus);
    s.syncAsByte(flags.myAGHeadBStatus);
    s.syncAsByte(flags.myAGHeadCStatus);
    s.syncAsByte(flags.myAGHeadDStatus);
    s.syncAsByte(flags.myAGHeadAStatusSkullID);
    s.syncAsByte(flags.myAGHeadBStatusSkullID);
    s.syncAsByte(flags.myAGHeadCStatusSkullID);
    s.syncAsByte(flags.myAGHeadDStatusSkullID);
    s.syncAsByte(flags.myAGTimerHeadID);
    SYNC_FLAG_UINT32(myAGTimerStartTime);
    s.syncAsByte(flags.myDGOfferedHeart);
    s.syncAsByte(flags.takenEnvironCart);
    s.syncAsByte(flags.alRDTakenLiveCore);
    s.syncAsByte(flags.alRDTakenDeadCore);
    s.syncAsByte(flags.alNMWrongAlienPrefixCode);
    s.syncAsByte(flags.faKIOvenStatus);
    s.syncAsByte(flags.faKIPostBoxSlotA);
    s.syncAsByte(flags.faKIPostBoxSlotB);
    s.syncAsByte(flags.faKIPostBoxSlotC);
    s.syncAsByte(flags.faERCurrentCartridge);
    s.syncAsByte(flags.faERTakenRemoteControl);
    s.syncAsByte(flags.myMCStingerID);
    s.syncAsByte(flags.myMCStingerChannelID);
    s.syncAsByte(flags.faStingerID);
    s.syncAsByte(flags.faStingerChannelID);
    s.syncBytes(flags.unused0, sizeof(flags.unused0));
    SYNC_FLAG_UINT32(cgMWCatapultData);
    SYNC_FLAG_UINT32(cgMWCatapultOffset);
    s.syncAsByte(flags.cgTSTriedDoor);
    s.syncAsByte(flags.cgMBCrossedMoat);
    s.syncAsByte(flags.cgKSSmithyEntryRead);
    s.syncAsByte(flags.cgKSSmithyEntryTranslated);
    s.syncAsByte(flags.cgBSFoundMold);
    s.syncAsByte(flags.readBurnedLetter);
    s.syncAsByte(flags.evcapNumCaptured);
    s.syncBytes(flags.evcapBaseID, sizeof(flags.evcapBaseID));
    s.syncBytes(flags.unused1, sizeof(flags.unused1));
    s.syncAsByte(flags.faMNEnvironDoor);
    s.syncAsByte(flags.faMNClockClicked);
    s.syncAsByte(flags.faMNBooksClicked);
    s.syncAsByte(flags.faMNTazClicked);
    s.syncAsByte(flags.faMNPongClicked);
    s.syncAsByte(flags.faKIBirdsBobbed);
    s.syncAsByte(flags.faKICoffeeSpilled);
    s.syncAsByte(flags.cgViewedKeepPlans);
    s.syncAsByte(flags.cgFoundChestPanel);
    s.syncAsByte(flags.cgTRFoundSword);
    s.syncAsByte(flags.faHeardAgentFigure);
    s.syncAsByte(flags.jumpBCNoInfoMessageCycle);
    s.syncAsByte(flags.myTPCalendarTopTranslated);
    s.syncAsByte(flags.myTPCalendarListTranslated);
    s.syncAsByte(flags.myTPTextTranslated);
    s.syncAsByte(flags.myMCTransDoor);
    s.syncAsByte(flags.myMCTransAGOffering);
    s.syncAsByte(flags.myMCTransWGOffering);
    s.syncAsByte(flags.myMCTransWTOffering);
    s.syncAsByte(flags.myMCTransDGOffering);
    s.syncAsByte(flags.myMCTransMadeAnOffering);
    s.syncAsByte(flags.myWGTransDoorTop);
    s.syncAsByte(flags.myWGSeenLowerPassage);
    s.syncAsByte(flags.myWGCrossedRopeBridge);
    s.syncAsByte(flags.myMCViewedDeathGodDoor);
    s.syncAsByte(flags.myTPTransBreathOfItzamna);
    SYNC_FLAG_UINT32(myAGHeadAOpenedTime);
    SYNC_FLAG_UINT32(myAGHeadBOpenedTime);
    SYNC_FLAG_UINT32(myAGHeadCOpenedTime);
    SYNC_FLAG_UINT32(myAGHeadDOpenedTime);
    s.syncAsByte(flags.myAGHeadATouched);
    s.syncAsByte(flags.myAGHeadBTouched);
    s.syncAsByte(flags.myAGHeadCTouched);
    s.syncAsByte(flags.myAGHeadDTouched);
    s.syncAsByte(flags.lensFilterActivated);
    s.syncAsByte(flags.dsPTElevatorPresent);
    s.syncAsByte(flags.dsPTElevatorLeverA);
    s.syncAsByte(flags.dsPTElevatorLeverB);
    s.syncAsByte(flags.dsPTDoorLocked);
    s.syncAsByte(flags.dsWSPickedUpWheelAssembly);
    s.syncAsByte(flags.dsWSPickedUpGearAssembly);
    s.syncAsByte(flags.dsWSPickedUpPegs);
    s.syncAsByte(flags.dsWSSiegeCycleStatus);
    s.syncAsByte(flags.dsWSGrabbedSiegeCycle);
    s.syncAsByte(flags.dsPTUseElevatorControls);
    s.syncAsByte(flags.dsPTTransElevatorControls);
    s.syncAsByte(flags.dsGDTakenCoilOfRope);
    s.syncAsByte(flags.dsCTUnlockedDoor);
    s.syncAsByte(flags.dsCTViewedAgent3);
    s.syncAsByte(flags.dsPTViewedAgent3);
    s.syncAsByte(flags.dsCTRetrievedLens);
    s.syncAsByte(flags.dsCTTakenHeart);
    s.syncAsByte(flags.dsCYFiredCannon);
    s.syncAsByte(flags.dsCYBallistaStatus);
    s.syncAsByte(flags.dsCYPlacedSiegeCycle);
    s.syncAsByte(flags.dsCYBallistaXPos);
    s.syncAsByte(flags.dsCYBallistaYPos);
    s.syncAsByte(flags.aiHWStingerID);
    s.syncAsByte(flags.aiHWStingerChannelID);
    s.syncAsByte(flags.aiCRStingerID);
    s.syncAsByte(flags.aiCRStingerChannelID);
    s.syncAsByte(flags.aiDBStingerID);
    s.syncAsByte(flags.aiDBStingerChannelID);
    s.syncAsByte(flags.aiCRGrabbedMetalBar);
    s.syncAsByte(flags.aiICGrabbedWaterCanister);
    s.syncAsByte(flags.aiOxygenTimer);
    s.syncAsByte(flags.aiCRPressurized);
    s.syncAsByte(flags.aiCRPressurizedAttempted);
    s.syncAsByte(flags.aiMRPressurized);
    s.syncAsByte(flags.aiIceMined);
    s.syncAsByte(flags.aiOxygenReserves);
    s.syncAsByte(flags.aiSCHeardInitialSpeech);
    s.syncAsByte(flags.aiSCInitialAudioChannel);
    s.syncAsByte(flags.aiSCDBDoorWarning);
    s.syncAsByte(flags.aiSCMoveCenterWarning);
    s.syncAsByte(flags.aiSCConversationStatus);
    s.syncAsByte(flags.aiHWIceDoorUnlocked);
    s.syncAsByte(flags.aiICWaterInFillHandle);
    s.syncAsByte(flags.aiICTakenWaterCanister);
    s.syncAsByte(flags.aiSWStingerID);
    s.syncAsByte(flags.aiSWStingerChannelID);
    s.syncAsByte(flags.aiMRCorrectFreqSet);
    s.syncAsByte(flags.aiSCHeardNexusDoorComment);
    s.syncAsByte(flags.aiSCHeardNexusDoorCode);
    s.syncAsByte(flags.asInitialGuardsPass);
    s.syncAsByte(flags.asRBPodAStatus);
    s.syncAsByte(flags.asRBPodBStatus);
    s.syncAsByte(flags.asRBPodCStatus);
    s.syncAsByte(flags.asRBPodDStatus);
    s.syncAsByte(flags.asRBPodEStatus);
    s.syncAsByte(flags.asRBPodFStatus);
    s.syncAsByte(flags.asRBPodATakenEnvironCart);
    s.syncAsByte(flags.asRBPodBTakenPuzzleBox);
    s.syncAsByte(flags.asRBPodCTakenCodex);
    s.syncAsByte(flags.asRBPodDTakenSculpture);
    s.syncAsByte(flags.asRBPodETakenSword);
    s.syncAsByte(flags.asTakenEvidenceThisTrip);
    s.syncAsByte(flags.asDangerDoorASealed);
    s.syncAsByte(flags.asDoorBGuardsSeen);
    s.syncAsByte(flags.asAmbassadorEncounter);
    s.syncAsByte(flags.dsCTTriedLockedDoor);
    s.syncAsByte(flags.dsCTCodexTranslateAttempted);
    s.syncAsByte(flags.dsCTCodexFormulaeFound);
    s.syncAsByte(flags.dsCTCodexAtlanticusPage2);
    s.syncAsByte(flags.dsCTTriedElevatorControls);
    s.syncAsByte(flags.aiDBPlayedMomComment);
    s.syncAsByte(flags.aiDBPlayedFirstArthur);
    s.syncAsByte(flags.aiDBPlayedSecondArthur);
    s.syncAsByte(flags.aiDBPlayedThirdArthur);
    s.syncAsByte(flags.aiDBPlayedFourthArthur);
    s.syncAsByte(flags.aiSCPlayedNoStinger);
    s.syncAsByte(flags.faKITakenPostboxItem);
    s.syncAsByte(flags.cgMBVisited);
    s.syncAsByte(flags.cgKCVisited);
    s.syncAsByte(flags.cgTRVisited);
    s.syncAsByte(flags.cgKSReadJournal);
    s.syncAsByte(flags.cgSRClickedOnLockedChest);
    s.syncAsByte(flags.cgSROpenedChest);
    s.syncAsByte(flags.dsVisitedCodexTower);
    s.syncAsByte(flags.dsPTRaisedPlatform);
    s.syncAsByte(flags.dsPTWalkedDownElevator);
    s.syncAsByte(flags.dsPTBeenOnBalcony);
    s.syncAsByte(flags.dsGDClickedOnCodexDoor);
    s.syncAsByte(flags.dsWSSeenCycleSketch);
    s.syncAsByte(flags.dsWSSeenBallistaSketch);
    s.syncAsByte(flags.genHadSiegeCycle);
    s.syncAsByte(flags.genHadDriveAssembly);
    s.syncAsByte(flags.genHadWheelAssembly);
    s.syncAsByte(flags.dsCYNeverConnectedHook);
    s.syncAsByte(flags.dsCYNeverShotBallista);
    s.syncAsByte(flags.dsCYNeverUsedCrank);
    s.syncAsByte(flags.dsCYNeverOpenedBalconyDoor);
    s.syncAsByte(flags.dsCYTranslatedCodex);
    s.syncAsByte(flags.dsCYTriedOpeningDoor);
    s.syncAsByte(flags.dsCYTriedElevator);
    s.syncAsByte(flags.dsCYFoundCodexes);
    s.syncAsByte(flags.myVisitedMainCavern);
    s.syncAsByte(flags.myVisitedArrowGod);
    s.syncAsByte(flags.myVisitedWaterGod);
    s.syncAsByte(flags.myVisitedWealthGod);
    s.syncAsByte(flags.myVisitedDeathGod);
    s.syncAsByte(flags.myVisitedSpecRooms);
    s.syncAsByte(flags.myWTSteppedOnSwings);
    s.syncAsByte(flags.myWTSteppedOnFarLedge);
    s.syncAsByte(flags.myDGOpenedPuzzleBox);
    s.syncAsByte(flags.myAGVisitedAltar);
    s.syncAsByte(flags.dsCTPlayedBallistaFalling);
    s.syncAsByte(flags.cgTSTriedDoorA);
    s.syncAsByte(flags.cgTSTriedDoorB);
    s.syncAsByte(flags.aiHWLastCommentPlayed);
    s.syncAsByte(flags.aiNXPlayedBrainComment);
    s.syncAsByte(flags.asRBLastStingerID);
    s.syncAsByte(flags.asRBStingerID);
    s.syncAsByte(flags.aiICProcessedOxygen);
    s.syncAsByte(flags.dsCYWeebleClicked);
    s.syncAsByte(flags.aiICUsedMiningControls);
    s.syncAsByte(flags.aiSWAttemptedPresMR);
    s.syncAsByte(flags.aiICRefilledOxygen);
    s.syncAsByte(flags.aiMRUsedHarmonicsInterface);
    s.syncAsByte(flags.alRestoreSkipAgent3Initial);
    s.syncBytes(flags.unused2, sizeof(flags.unused2));
    s.syncAsByte(flags.scoreGotTranslateBioChip);
    s.syncAsByte(flags.scoreEnteredSpaceStation);
    s.syncAsByte(flags.scoreDownloadedArthur);
    s.syncAsByte(flags.scoreFoundSculptureDiagram);
    s.syncAsByte(flags.scoreEnteredKeep);
    s.syncAsByte(flags.scoreGotKeyFromSmithy);
    s.syncAsByte(flags.scoreEnteredTreasureRoom);
    s.syncAsByte(flags.scoreFoundSwordDiamond);
    s.syncAsByte(flags.scoreMadeSiegeCycle);
    s.syncAsByte(flags.scoreEnteredCodexTower);
    s.syncAsByte(flags.scoreLoggedCodexEvidence);
    s.syncAsByte(flags.scoreEnteredMainCavern);
    s.syncAsByte(flags.scoreGotWealthGodPiece);
    s.syncAsByte(flags.scoreGotRainGodPiece);
    s.syncAsByte(flags.scoreGotWarGodPiece);
    s.syncAsByte(flags.scoreCompletedDeathGod);
    s.syncAsByte(flags.scoreEliminatedAgent3);
    s.syncAsByte(flags.scoreTransportToKrynn);
    s.syncAsByte(flags.scoreGotKrynnArtifacts);
    s.syncAsByte(flags.scoreDefeatedIcarus);
    s.syncAsByte(flags.scoreResearchINNLouvreReport);
    s.syncAsByte(flags.scoreResearchINNHighBidder);
    s.syncAsByte(flags.scoreResearchINNAppeal);
    s.syncAsByte(flags.scoreResearchINNUpdate);
    s.syncAsByte(flags.scoreResearchINNJumpsuit);
    s.syncAsByte(flags.scoreResearchBCJumpsuit);
    s.syncAsByte(flags.scoreResearchMichelle);
    s.syncAsByte(flags.scoreResearchMichelleBkg);
    s.syncAsByte(flags.scoreResearchLensFilter);
    s.syncAsByte(flags.scoreResearchCastleFootprint);
    s.syncAsByte(flags.scoreResearchDaVinciFootprint);
    s.syncAsByte(flags.scoreResearchMorphSculpture);
    s.syncAsByte(flags.scoreResearchEnvironCart);
    s.syncAsByte(flags.scoreResearchAgent3Note);
    s.syncAsByte(flags.scoreResearchAgent3DaVinci);
    SYNC_FLAG_UINT16(scoreHintsTotal);
    s.syncBytes(flags.unused3, sizeof(flags.unused3));
    s.syncAsByte(flags.genJumpCastleBriefing);
    s.syncAsByte(flags.genJumpMayanBriefing);
    s.syncAsByte(flags.genJumpDaVinciBriefing);
    s.syncAsByte(flags.genJumpStationBriefing);
    s.syncBytes(flags.unused4, sizeof(flags.unused4));
    s.syncAsByte(flags.generalWalkthroughMode);
    s.syncBytes(flags.unused5, sizeof(flags.unused5));
    s.syncBytes(flags.aiData, sizeof(flags.aiData));

    return s.bytesSynced() - startBytes == 1024;
}
Example #20
0
static void syncOverlays2(Common::Serializer &s) {

	for (int i = 1; i < numOfLoadedOverlay; i++) {

		if (s.isSaving()) {
			// Saving code
			if (!overlayTable[i].alreadyLoaded)
				continue;

			ovlDataStruct *ovlData = overlayTable[i].ovlData;

			// save BSS
			s.syncAsSint16LE(ovlData->sizeOfData4);
			if (ovlData->sizeOfData4)
				s.syncBytes(ovlData->data4Ptr, ovlData->sizeOfData4);

			// save variables
			s.syncAsSint16LE(ovlData->size9);
			for (int j = 0; j < ovlData->size9; j++) {
				s.syncAsSint16LE(ovlData->arrayObjVar[j].X);
				s.syncAsSint16LE(ovlData->arrayObjVar[j].Y);
				s.syncAsSint16LE(ovlData->arrayObjVar[j].Z);
				s.syncAsSint16LE(ovlData->arrayObjVar[j].frame);
				s.syncAsSint16LE(ovlData->arrayObjVar[j].scale);
				s.syncAsSint16LE(ovlData->arrayObjVar[j].state);
			}
		} else {
			// Loading code
			ovlRestoreData[i]._sBssSize = ovlRestoreData[i]._sNumObj = 0;
			ovlRestoreData[i]._pBss = NULL;
			ovlRestoreData[i]._pObj = NULL;

			if (overlayTable[i].alreadyLoaded) {
				s.syncAsSint16LE(ovlRestoreData[i]._sBssSize);

				if (ovlRestoreData[i]._sBssSize) {
					ovlRestoreData[i]._pBss = (uint8 *) mallocAndZero(ovlRestoreData[i]._sBssSize);
					ASSERT(ovlRestoreData[i]._pBss);

					s.syncBytes(ovlRestoreData[i]._pBss, ovlRestoreData[i]._sBssSize);
				}

				s.syncAsSint16LE(ovlRestoreData[i]._sNumObj);

				if (ovlRestoreData[i]._sNumObj) {
					ovlRestoreData[i]._pObj = (objectParams *) mallocAndZero(ovlRestoreData[i]._sNumObj * sizeof(objectParams));
					ASSERT(ovlRestoreData[i]._pObj);

					for (int j = 0; j < ovlRestoreData[i]._sNumObj; j++) {
						s.syncAsSint16LE(ovlRestoreData[i]._pObj[j].X);
						s.syncAsSint16LE(ovlRestoreData[i]._pObj[j].Y);
						s.syncAsSint16LE(ovlRestoreData[i]._pObj[j].Z);
						s.syncAsSint16LE(ovlRestoreData[i]._pObj[j].frame);
						s.syncAsSint16LE(ovlRestoreData[i]._pObj[j].scale);
						s.syncAsSint16LE(ovlRestoreData[i]._pObj[j].state);
					}
				}
			}
		}
	}
}
Example #21
0
void Sequence::synchronize(Common::Serializer &sz) {
	sz.syncBytes(_seq, kSeqLength);
	sz.syncAsByte(_flipToWhere);
	sz.syncAsByte(_flipToPed);
}