C++ Serializer::skip方法代码示例

static void syncWithSerializer(Common::Serializer &s, Track &t) {
	s.syncAsSByte(t.pan, VER(31));
	s.syncAsSint32LE(t.vol, VER(31));
	s.syncAsSint32LE(t.volFadeDest, VER(31));
	s.syncAsSint32LE(t.volFadeStep, VER(31));
	s.syncAsSint32LE(t.volFadeDelay, VER(31));
	s.syncAsByte(t.volFadeUsed, VER(31));
	s.syncAsSint32LE(t.soundId, VER(31));
	s.syncArray(t.soundName, 15, Common::Serializer::SByte, VER(31));
	s.syncAsByte(t.used, VER(31));
	s.syncAsByte(t.toBeRemoved, VER(31));
	s.syncAsByte(t.souStreamUsed, VER(31));
	s.skip(1, VER(31), VER(76)); // mixerStreamRunning
	s.syncAsSint32LE(t.soundPriority, VER(31));
	s.syncAsSint32LE(t.regionOffset, VER(31));
	s.skip(4, VER(31), VER(31)); // trackOffset
	s.syncAsSint32LE(t.dataOffset, VER(31));
	s.syncAsSint32LE(t.curRegion, VER(31));
	s.syncAsSint32LE(t.curHookId, VER(31));
	s.syncAsSint32LE(t.volGroupId, VER(31));
	s.syncAsSint32LE(t.soundType, VER(31));
	s.syncAsSint32LE(t.feedSize, VER(31));
	s.syncAsSint32LE(t.dataMod12Bit, VER(31));
	s.syncAsSint32LE(t.mixerFlags, VER(31));
	s.skip(4, VER(31), VER(42)); // mixerVol
	s.skip(4, VER(31), VER(42)); // mixerPan
	s.syncAsByte(t.sndDataExtComp, VER(45));
}

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

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

//////////////////////////////////////////////////////////////////////////
// Serializable
//////////////////////////////////////////////////////////////////////////
void SavePoints::saveLoadWithSerializer(Common::Serializer &s) {

	// Serialize savepoint data
	uint32 dataSize = (s.isLoading() ? _savePointsMaxSize : _data.size());
	for (uint i = 0; i < dataSize; i++) {
		if (s.isLoading()) {
			SavePointData data;
			_data.push_back(data);
		}

		s.syncAsUint32LE(_data[i].entity1);
		s.syncAsUint32LE(_data[i].action);
		s.syncAsUint32LE(_data[i].entity2);
		s.syncAsUint32LE(_data[i].param);
	}

	// Skip uninitialized data if any
	s.skip((_savePointsMaxSize - dataSize) * 16);

	// Number of savepoints
	uint32 numSavepoints = _savepoints.size();
	s.syncAsUint32LE(numSavepoints);

	// Savepoints
	if (s.isLoading()) {
		for (uint i = 0; i < numSavepoints; i++) {
			SavePoint point;
			s.syncAsUint32LE(point.entity1);
			s.syncAsUint32LE(point.action);
			s.syncAsUint32LE(point.entity2);
			s.syncAsUint32LE(point.param.intValue);

			_savepoints.push_back(point);

			if (_savepoints.size() >= _savePointsMaxSize)
				break;
		}
	} else {
		for (Common::List<SavePoint>::iterator it = _savepoints.begin(); it != _savepoints.end(); ++it) {
			s.syncAsUint32LE((*it).entity1);
			s.syncAsUint32LE((*it).action);
			s.syncAsUint32LE((*it).entity2);
			s.syncAsUint32LE((*it).param.intValue);
		}
	}
}

void EntityData::EntityCallData::saveLoadWithSerializer(Common::Serializer &s) {
	for (uint i = 0; i < ARRAYSIZE(callbacks); i++)
		s.syncAsByte(callbacks[i]);

	s.syncAsByte(currentCall);
	s.syncAsUint16LE(entityPosition);
	s.syncAsUint16LE(location);
	s.syncAsUint16LE(car);
	s.syncAsByte(field_497);
	s.syncAsByte(entity);
	s.syncAsByte(inventoryItem);
	s.syncAsByte(direction);
	s.syncAsUint16LE(field_49B);
	s.syncAsUint16LE(currentFrame);
	s.syncAsUint16LE(currentFrame2);
	s.syncAsUint16LE(field_4A1);
	s.syncAsUint16LE(field_4A3);
	s.syncAsByte(clothes);
	s.syncAsByte(position);
	s.syncAsByte(car2);
	s.syncAsByte(doProcessEntity);
	s.syncAsByte(field_4A9);
	s.syncAsByte(field_4AA);
	s.syncAsByte(directionSwitch);

	// Sync strings
#define SYNC_STRING(varName, count) { \
	char seqName[13]; \
	memset(&seqName, 0, count); \
	if (s.isSaving()) strcpy((char *)&seqName, varName.c_str()); \
	s.syncBytes((byte *)&seqName, count); \
	if (s.isLoading()) varName = seqName; \
}

	SYNC_STRING(sequenceName, 13);
	SYNC_STRING(sequenceName2, 13);
	SYNC_STRING(sequenceNamePrefix, 7);
	SYNC_STRING(sequenceNameCopy, 13);

#undef SYNC_STRING

	// Skip pointers to frame & sequences
	s.skip(5 * 4);
}

//////////////////////////////////////////////////////////////////////////
// Savegame
//////////////////////////////////////////////////////////////////////////
void SoundQueue::saveLoadWithSerializer(Common::Serializer &s) {
	Common::StackLock locker(_mutex);

	s.syncAsUint32LE(_state);
	s.syncAsUint32LE(_currentType);

	// Compute the number of entries to save
	uint32 numEntries = count();
	s.syncAsUint32LE(numEntries);

	// Save or load each entry data
	if (s.isSaving()) {
		for (Common::List<SoundEntry *>::iterator i = _soundList.begin(); i != _soundList.end(); ++i)
			(*i)->saveLoadWithSerializer(s);
	} else {
		warning("[Sound::saveLoadWithSerializer] Loading not implemented");
		s.skip(numEntries * 64);
	}
}

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

}

void MystGameState::syncGameState(Common::Serializer &s, bool isME) {
    // Globals first
    s.syncAsUint16LE(_globals.u0);
    s.syncAsUint16LE(_globals.currentAge);
    s.syncAsUint16LE(_globals.heldPage);
    s.syncAsUint16LE(_globals.u1);
    s.syncAsUint16LE(_globals.transitions);
    s.syncAsUint16LE(_globals.zipMode);
    s.syncAsUint16LE(_globals.redPagesInBook);
    s.syncAsUint16LE(_globals.bluePagesInBook);

    // Onto Myst
    if (isME) {
        s.syncAsUint32LE(_myst.cabinMarkerSwitch);
        s.syncAsUint32LE(_myst.clockTowerMarkerSwitch);
        s.syncAsUint32LE(_myst.dockMarkerSwitch);
        s.syncAsUint32LE(_myst.poolMarkerSwitch);
        s.syncAsUint32LE(_myst.gearsMarkerSwitch);
        s.syncAsUint32LE(_myst.generatorMarkerSwitch);
        s.syncAsUint32LE(_myst.observatoryMarkerSwitch);
        s.syncAsUint32LE(_myst.rocketshipMarkerSwitch);
    } else {
        s.syncAsByte(_myst.cabinMarkerSwitch);
        s.syncAsByte(_myst.clockTowerMarkerSwitch);
        s.syncAsByte(_myst.dockMarkerSwitch);
        s.syncAsByte(_myst.poolMarkerSwitch);
        s.syncAsByte(_myst.gearsMarkerSwitch);
        s.syncAsByte(_myst.generatorMarkerSwitch);
        s.syncAsByte(_myst.observatoryMarkerSwitch);
        s.syncAsByte(_myst.rocketshipMarkerSwitch);
    }

    s.syncAsUint16LE(_myst.greenBookOpenedBefore);
    s.syncAsUint16LE(_myst.shipFloating);
    s.syncAsUint16LE(_myst.cabinValvePosition);
    s.syncAsUint16LE(_myst.clockTowerHourPosition);
    s.syncAsUint16LE(_myst.clockTowerMinutePosition);
    s.syncAsUint16LE(_myst.gearsOpen);
    s.syncAsUint16LE(_myst.clockTowerBridgeOpen);
    s.syncAsUint16LE(_myst.generatorBreakers);
    s.syncAsUint16LE(_myst.generatorButtons);
    s.syncAsUint16LE(_myst.generatorVoltage);
    s.syncAsUint16LE(_myst.libraryBookcaseDoor);
    s.syncAsUint16LE(_myst.imagerSelection);
    s.syncAsUint16LE(_myst.imagerActive);
    s.syncAsUint16LE(_myst.imagerWaterErased);
    s.syncAsUint16LE(_myst.imagerMountainErased);
    s.syncAsUint16LE(_myst.imagerAtrusErased);
    s.syncAsUint16LE(_myst.imagerMarkerErased);
    s.syncAsUint16LE(_myst.towerRotationAngle);
    s.syncAsUint16LE(_myst.courtyardImageBoxes);
    s.syncAsUint16LE(_myst.cabinPilotLightLit);
    s.syncAsUint16LE(_myst.observatoryDaySetting);
    s.syncAsUint16LE(_myst.observatoryLights);
    s.syncAsUint16LE(_myst.observatoryMonthSetting);
    s.syncAsUint16LE(_myst.observatoryTimeSetting);
    s.syncAsUint16LE(_myst.observatoryYearSetting);
    s.syncAsUint16LE(_myst.observatoryDayTarget);
    s.syncAsUint16LE(_myst.observatoryMonthTarget);
    s.syncAsUint16LE(_myst.observatoryTimeTarget);
    s.syncAsUint16LE(_myst.observatoryYearTarget);
    s.syncAsUint16LE(_myst.cabinSafeCombination);
    s.syncAsUint16LE(_myst.treePosition);
    s.syncAsUint32LE(_myst.treeLastMoveTime);

    for (int i = 0; i < 5; i++)
        s.syncAsUint16LE(_myst.rocketSliderPosition[i]);

    s.syncAsUint16LE(_myst.observatoryDaySlider);
    s.syncAsUint16LE(_myst.observatoryMonthSlider);
    s.syncAsUint16LE(_myst.observatoryYearSlider);
    s.syncAsUint16LE(_myst.observatoryTimeSlider);

    // Channelwood
    if (isME) {
        s.syncAsUint32LE(_channelwood.waterPumpBridgeState);
        s.syncAsUint32LE(_channelwood.elevatorState);
        s.syncAsUint32LE(_channelwood.stairsLowerDoorState);
        s.syncAsUint32LE(_channelwood.pipeState);
    } else {
        s.syncAsByte(_channelwood.waterPumpBridgeState);
        s.syncAsByte(_channelwood.elevatorState);
        s.syncAsByte(_channelwood.stairsLowerDoorState);
        s.syncAsByte(_channelwood.pipeState);
    }

    s.syncAsUint16LE(_channelwood.waterValveStates);
    s.syncAsUint16LE(_channelwood.holoprojectorSelection);
    s.syncAsUint16LE(_channelwood.stairsUpperDoorState);

    if (isME)
        s.skip(4);
    else
        s.skip(1);

    // Mechanical

    s.syncAsUint16LE(_mechanical.achenarPanelState);
    s.syncAsUint16LE(_mechanical.sirrusPanelState);
    s.syncAsUint16LE(_mechanical.staircaseState);
//.........这里部分代码省略.........

void IMuseDigital::saveLoadEarly(Common::Serializer &s) {
	Common::StackLock lock(_mutex, "IMuseDigital::saveLoadEarly()");

	s.skip(4, VER(31), VER(42)); // _volVoice
	s.skip(4, VER(31), VER(42)); // _volSfx
	s.skip(4, VER(31), VER(42)); // _volMusic
	s.syncAsSint32LE(_curMusicState, VER(31));
	s.syncAsSint32LE(_curMusicSeq, VER(31));
	s.syncAsSint32LE(_curMusicCue, VER(31));
	s.syncAsSint32LE(_nextSeqToPlay, VER(31));
	s.syncAsByte(_radioChatterSFX, VER(76));
	s.syncArray(_attributes, 188, Common::Serializer::Sint32LE, VER(31));

	for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
		Track *track = _track[l];
		if (s.isLoading()) {
			memset(track, 0, sizeof(Track));
		}
		syncWithSerializer(s, *track);
		if (s.isLoading()) {
			_track[l]->trackId = l;
			if (!track->used)
				continue;
			if ((track->toBeRemoved) || (track->souStreamUsed) || (track->curRegion == -1)) {
				track->used = false;
				continue;
			}

			// TODO: The code below has a lot in common with that in IMuseDigital::startSound.
			// Try to refactor them to reduce the code duplication.

			track->soundDesc = _sound->openSound(track->soundId, track->soundName, track->soundType, track->volGroupId, -1);
			if (!track->soundDesc)
				track->soundDesc = _sound->openSound(track->soundId, track->soundName, track->soundType, track->volGroupId, 1);
			if (!track->soundDesc)
				track->soundDesc = _sound->openSound(track->soundId, track->soundName, track->soundType, track->volGroupId, 2);

			if (!track->soundDesc) {
				warning("IMuseDigital::saveOrLoad: Can't open sound so will not be resumed");
				track->used = false;
				continue;
			}

			track->sndDataExtComp = _sound->isSndDataExtComp(track->soundDesc);
			track->dataOffset = _sound->getRegionOffset(track->soundDesc, track->curRegion);
			int bits = _sound->getBits(track->soundDesc);
			int channels = _sound->getChannels(track->soundDesc);
			int freq = _sound->getFreq(track->soundDesc);
			track->feedSize = freq * channels;
			track->mixerFlags = 0;
			if (channels == 2)
				track->mixerFlags = kFlagStereo;

			if ((bits == 12) || (bits == 16)) {
				track->mixerFlags |= kFlag16Bits;
				track->feedSize *= 2;
			} else if (bits == 8) {
				track->mixerFlags |= kFlagUnsigned;
			} else
				error("IMuseDigital::saveOrLoad(): Can't handle %d bit samples", bits);

			track->stream = Audio::makeQueuingAudioStream(freq, (track->mixerFlags & kFlagStereo) != 0);

			_mixer->playStream(track->getType(), &track->mixChanHandle, track->stream, -1, track->getVol(), track->getPan());
			_mixer->pauseHandle(track->mixChanHandle, true);
		}
	}
}