protected virtual void SerializeLocaleStrings <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (var bm = s.EnterCursorBookmarkOpt("StringTable", this, _obj => _obj.StringTableIsNotDefault)) if (bm.IsNotNull)
{
s.StreamObject(StringTable);
SerializeStringTableIndexOpt(s, "baseNameIndex", ref BaseNameStringIndex);
}
else
{
StringTableRevertToDefault();
}
using (var bm = s.EnterCursorBookmarkOpt("NameString", NameString, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamObject(NameString);
}
using (var bm = s.EnterCursorBookmarkOpt("DescString", DescriptionString, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamObject(DescriptionString);
}
using (var bm = s.EnterCursorBookmarkOpt("CategoryString", CategoryString, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamObject(CategoryString);
}
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.Serialize(s);
using (s.EnterCursorBookmark("Powerups"))
{
Predicate <PlayerTraits> traits_are_changed = obj => !obj.IsUnchanged;
using (var bm = s.EnterCursorBookmarkOpt("Red", Red, traits_are_changed)) if (bm.IsNotNull)
{
s.StreamAttribute("duration", ref RedDuration);
s.StreamObject(Red);
}
using (var bm = s.EnterCursorBookmarkOpt("Blue", Blue, traits_are_changed)) if (bm.IsNotNull)
{
s.StreamAttribute("duration", ref BlueDuration);
s.StreamObject(Blue);
}
using (var bm = s.EnterCursorBookmarkOpt("Yellow", Yellow, traits_are_changed)) if (bm.IsNotNull)
{
s.StreamAttribute("duration", ref YellowDuration);
s.StreamObject(Yellow);
}
}
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.Serialize(s);
using (s.EnterCursorBookmark("Powerups"))
{
GameOptionsPowerup pu;
Predicate <GameOptionsPowerup> pu_is_not_default = obj => !obj.IsUnchanged;
pu = Powerups[0];
using (var bm = s.EnterCursorBookmarkOpt("DamageBoost", pu, pu_is_not_default)) if (bm.IsNotNull)
{
s.StreamObject(pu);
}
pu = Powerups[1];
using (var bm = s.EnterCursorBookmarkOpt("SpeedBoost", pu, pu_is_not_default)) if (bm.IsNotNull)
{
s.StreamObject(pu);
}
pu = Powerups[2];
using (var bm = s.EnterCursorBookmarkOpt("Overshield", pu, pu_is_not_default)) if (bm.IsNotNull)
{
s.StreamObject(pu);
}
pu = Powerups[3];
using (var bm = s.EnterCursorBookmarkOpt("Custom", pu, pu_is_not_default)) if (bm.IsNotNull)
{
s.StreamObject(pu);
}
}
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
s.StreamAttributeEnumOpt("flags", ref Flags, flags => flags != 0, true);
if (!s.StreamAttributeOpt("infinityMissionId", ref InfinityMissionId, Predicates.IsNotNone))
{
InfinityMissionId = TypeExtensions.kNone;
}
SerializeContentHeader(s);
SerializeMiscOptions(s);
using (var bm = s.EnterCursorBookmarkOpt("Prototype", OptionsPrototype, obj => !obj.IsEmpty)) if (bm.IsNotNull)
{
s.StreamObject(OptionsPrototype);
}
SerializRespawnOptions(s);
SerializeSocialOptions(s);
SerializMapOverrides(s);
using (var bm = s.EnterCursorBookmarkOpt("Requisitions", OptionsRequisitions, obj => !obj.IsDefault)) if (bm.IsNotNull)
{
s.StreamObject(OptionsRequisitions);
}
SerializeTeams(s);
SerializeLoadoutOptions(s);
using (var bm = s.EnterCursorBookmarkOpt("Ordnance", OrdnanceOptions, obj => !obj.IsDefault)) if (bm.IsNotNull)
{
s.StreamObject(OrdnanceOptions);
}
else if (s.IsReading)
{
OrdnanceOptions.RevertToDefault();
}
}
public virtual void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (var bm = s.EnterCursorBookmarkOpt("Damage", Damage, obj => !obj.IsUnchanged)) if (bm.IsNotNull)
{
s.StreamObject(Damage);
}
using (var bm = s.EnterCursorBookmarkOpt("Weapons", Weapons, obj => !obj.IsUnchanged)) if (bm.IsNotNull)
{
s.StreamObject(Weapons);
}
using (var bm = s.EnterCursorBookmarkOpt("Movement", Movement, obj => !obj.IsUnchanged)) if (bm.IsNotNull)
{
s.StreamObject(Movement);
}
using (var bm = s.EnterCursorBookmarkOpt("Appearance", Appearance, obj => !obj.IsUnchanged)) if (bm.IsNotNull)
{
s.StreamObject(Appearance);
}
using (var bm = s.EnterCursorBookmarkOpt("Sensors", Sensors, obj => !obj.IsUnchanged)) if (bm.IsNotNull)
{
s.StreamObject(Sensors);
}
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.Serialize(s);
s.StreamAttributeOptUnchangedZero("camo", ref ActiveCamo);
s.StreamAttributeOptUnchangedZero("waypoint", ref Waypoint);
s.StreamAttributeOptUnchangedZero("gamertag", ref GamertagVisible);
s.StreamAttributeOptUnchangedZero("aura", ref Aura);
s.StreamAttributeOptUnchangedZero("shieldHud", ref ShieldHud);
using (var bm = s.EnterCursorBookmarkOpt("Effects", this, obj => obj.EffectsAreNotDefault)) if (bm.IsNotNull)
{
s.StreamAttributeOptDefaultOption("death", ref DeathEffect);
s.StreamAttributeOptDefaultOption("looping", ref LoopingEffect);
}
using (var bm = s.EnterCursorBookmarkOpt("PrimaryColor", PrimaryColor, obj => !obj.IsDefault)) if (bm.IsNotNull)
{
s.StreamObject(PrimaryColor);
}
using (var bm = s.EnterCursorBookmarkOpt("SecondaryColor", SecondaryColor, obj => !obj.IsDefault)) if (bm.IsNotNull)
{
s.StreamObject(SecondaryColor);
}
using (var bm = s.EnterCursorBookmarkOpt("Model", ModelVariant, obj => !obj.IsDefault)) if (bm.IsNotNull)
{
s.StreamObject(ModelVariant);
}
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.Serialize(s);
s.StreamAttributeOptUnchangedZero("pickupAllowed", ref WeaponPickupAllowed);
s.StreamAttributeOptUnchangedZero("infAmmo", ref InfAmmo);
#region Equipment
using (var bm = s.EnterCursorBookmarkOpt("Equipment", this, obj => !obj.EquipmentIsUnchanged)) if (bm.IsNotNull)
{
s.StreamAttributeOptUnchangedZero("drop", ref EquipmentDrop);
s.StreamAttributeOptUnchangedZero("infinite", ref InfEquipment);
s.StreamAttributeOptUnchangedZero("usage", ref EquipmentUsage);
s.StreamAttributeOptUnchangedZero("rechargingGrenades", ref RechargingGrenades);
}
#endregion
#region Loadout
using (var bm = s.EnterCursorBookmarkOpt("InitLoadout", this, obj => !obj.LoadoutIsUnchanged)) if (bm.IsNotNull)
{
s.StreamAttributeOptUnchanged("primaryWeapon", ref InitialPrimaryWeapon);
s.StreamAttributeOptUnchanged("secondaryWeapon", ref InitialSecondaryWeapon);
s.StreamAttributeOptUnchangedZero("grenadeCount", ref InitialGrenadeCount);
s.StreamAttributeOptUnchanged("equipment", ref InitialEquipment);
}
#endregion
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
var xs = s.GetSerializerInterface();
using (s.EnterCursorBookmark("Attributes"))
{
base.Serialize(s);
using (var bm = s.EnterCursorBookmarkOpt("Cost", Cost, x => x.HasNonZeroItems)) if (bm.IsNotNull)
{
XML.XmlUtil.SerializeCostHack(s, Cost);
}
XML.XmlUtil.Serialize(s, DynamicCosts, BPowerDynamicCost.kBListXmlParams);
XML.XmlUtil.Serialize(s, TargetEffectiveness, BPowerTargetEffectiveness.kBListXmlParams);
XML.XmlUtil.Serialize(s, Populations, BPopulation.kBListXmlParamsSingle_LowerCase);
s.StreamElementOpt("UIRadius", ref mUIRadius, Predicates.IsNotZero);
s.StreamElementEnumOpt("PowerType", ref mPowerType, e => e != BPowerType.Invalid);
s.StreamElementOpt("AutoRecharge", ref mAutoRecharge, Predicates.IsNotZero);
s.StreamElementOpt("UseLimit", ref mUseLimit, Predicates.IsNotZero);
XML.XmlUtil.Serialize(s, Flags, XML.BBitSetXmlParams.kFlagsAreElementNamesThatMeanTrue);
XML.XmlUtil.Serialize(s, Flags2, XML.BBitSetXmlParams.kFlagsAreElementNamesThatMeanTrue);
s.StreamElementOpt("Icon", ref mIconTextureName, Predicates.IsNotNullOrEmpty);
s.StreamElements("IconLocation", IconLocations, xs, StreamIconLocation);
s.StreamElements("TechPrereq", TechPrereqs, xs, XML.BDatabaseXmlSerializerBase.StreamTechID);
s.StreamElementEnumOpt("Action", ref mActionType, BProtoAction.kNotInvalidActionType);
s.StreamElementEnumOpt("Minigame", ref mMinigameType, e => e != BMinigameType.None);
s.StreamElementOpt("CameraZoomMin", ref mCameraZoomMin, Predicates.IsNotZero);
s.StreamElementOpt("CameraZoomMax", ref mCameraZoomMax, Predicates.IsNotZero);
s.StreamElementOpt("CameraPitchMin", ref mCameraPitchMin, Predicates.IsNotZero);
s.StreamElementOpt("CameraPitchMax", ref mCameraPitchMax, Predicates.IsNotZero);
s.StreamElementOpt("CameraEffectIn", ref mCameraEffectIn, Predicates.IsNotNullOrEmpty);
s.StreamElementOpt("CameraEffectOut", ref mCameraEffectOut, Predicates.IsNotNullOrEmpty);
s.StreamElementOpt("MinDistanceToSquad", ref mMinDistanceToSquad, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("MaxDistanceToSquad", ref mMaxDistanceToSquad, PhxPredicates.IsNotInvalid);
using (var bm = s.EnterCursorBookmarkOpt("ShowTargetHighlight", this, x => x.HasShowTargetHighlightData)) if (bm.IsNotNull)
{
xs.StreamDBID(s, "ObjectType", ref mShowTargetHighlightObjectType, DatabaseObjectKind.ObjectType, xmlSource: XML.XmlUtil.kSourceAttr);
s.StreamAttributeEnumOpt("Relation", ref mShowTargetHighlightRelation, e => e != BRelationType.Any);
}
using (var bm = s.EnterCursorBookmarkOpt("ChildObjects", ChildObjectIDs, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamElements("Object", ChildObjectIDs, xs, XML.BDatabaseXmlSerializerBase.StreamObjectID);
}
using (var bm = s.EnterCursorBookmarkOpt("BaseDataLevel", this, x => x.BaseDataLevel != null)) if (bm.IsNotNull)
{
if (s.IsReading)
{
mBaseDataLevel = new BProtoPowerDataLevel();
}
BaseDataLevel.Serialize(s);
}
XML.XmlUtil.Serialize(s, LevelData, BProtoPowerDataLevel.kBListExplicitIndexXmlParams);
}
s.StreamElementOpt("TriggerScript", ref mTriggerScript, Predicates.IsNotNullOrEmpty);
s.StreamElementOpt("CommandTriggerScript", ref mCommandTriggerScript, Predicates.IsNotNullOrEmpty);
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.Serialize(s);
bool reading = s.IsReading;
s.StreamAttributeOptUnchangedZero("pickupAllowed", ref WeaponPickupAllowed);
s.StreamAttributeOptUnchangedZero("infAmmo", ref InfAmmo);
#region Equipment
using (var bm = s.EnterCursorBookmarkOpt("Equipment", this, obj => !obj.EquipmentIsUnchanged)) if (bm.IsNotNull)
{
s.StreamAttributeOptUnchangedZero("drop", ref EquipmentDrop);
s.StreamAttributeOptUnchangedZero("infinite", ref InfEquipment);
s.StreamAttributeOptUnchangedZero("usage", ref EquipmentUsage);
s.StreamAttributeOptUnchangedZero("usageSansAutoTurret", ref EquipmentUsageExceptingAutoTurret);
}
#endregion
#region Ordnance
using (var bm = s.EnterCursorBookmarkOpt("Ordnance", this, obj => !obj.OrdnanceIsUnchanged)) if (bm.IsNotNull)
{
s.StreamAttributeOptUnchangedZero("disabled", ref OrdnanceDisabled);
s.StreamAttributeOptUnchangedZero("markersVisability", ref OrdnanceMarkersVisable);
s.StreamAttributeOptUnchangedZero("allowReroll", ref OrdnanceRerollAvailable);
}
#endregion
#region Loadout
using (var bm = s.EnterCursorBookmarkOpt("InitLoadout", this, obj => !obj.LoadoutIsUnchanged)) if (bm.IsNotNull)
{
s.StreamAttributeOptUnchanged("primaryWeapon", ref InitialPrimaryWeapon);
s.StreamAttributeOptUnchanged("secondaryWeapon", ref InitialSecondaryWeapon);
s.StreamAttributeOptUnchangedZero("grenadeCount", ref InitialGrenadeCount);
s.StreamAttributeOptUnchanged("equipment", ref InitialEquipment);
s.StreamAttributeOptUnchanged("tacticalPackage", ref InitialTacticalPackage);
s.StreamAttributeOptUnchanged("supportUpgrade", ref InitialSupportUpgrade);
}
#endregion
#region Apps
using (var bm = s.EnterCursorBookmarkOpt("Apps", this, obj => !obj.AppsAreUnchanged)) if (bm.IsNotNull)
{
s.StreamAttributeOptUnchangedZero("resourceful", ref Resourceful);
s.StreamAttributeOptUnchangedZero("wellEquipped", ref WellEquipped);
s.StreamAttributeOptUnchangedZero("ammopack", ref Ammopack);
s.StreamAttributeOptUnchangedZero("grenadier", ref Grenadier);
s.StreamAttributeOptUnchangedZero("explodeOnDeath", ref ExplodeOnDeathArmorMod);
}
#endregion
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (var bm = s.EnterCursorBookmarkOpt("Primary", Primary, obj => !obj.IsUnchanged)) if (bm.IsNotNull)
{
Primary.Serialize(s);
}
using (var bm = s.EnterCursorBookmarkOpt("Secondary", Secondary, obj => !obj.IsUnchanged)) if (bm.IsNotNull)
{
Secondary.Serialize(s);
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (var bm = s.EnterCursorBookmarkOpt("Base", BaseTraits, obj => !obj.IsUnchanged)) if (bm.IsNotNull)
{
s.StreamObject(BaseTraits);
}
using (var bm = s.EnterCursorBookmarkOpt("Runtime", RuntimeTraits, obj => !obj.IsUnchanged)) if (bm.IsNotNull)
{
s.StreamObject(RuntimeTraits);
}
}
public virtual void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamAttributeEnumOpt("flags", ref Flags, flags => flags != 0, true);
using (var bm = s.EnterCursorBookmarkOpt("ObjectSets", this, obj => obj.ObjectSetsAreNotDefault)) if (bm.IsNotNull)
{
SerializeObjectSets(s);
}
using (var bm = s.EnterCursorBookmarkOpt("BaseTraits", BaseTraits, t => !t.IsUnchanged)) if (bm.IsNotNull)
{
s.StreamObject(BaseTraits);
}
}
protected virtual void SerializeImpl <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (s.EnterCursorBookmark("SerializeFlags"))
s.StreamCursorEnum(ref TagElementStreamSerializeFlags, true);
s.StreamAttribute("encoding", ref mEncodingVersion, NumeralBase.Hex);
s.StreamAttribute("version", ref EngineVersion);
// Must come first. Most of the other variant data contains string references
SerializeLocaleStrings(s);
using (var bm = s.EnterCursorBookmarkOpt("PlayerTraits", PlayerTraits, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamableElements("entry", PlayerTraits, this, _this => _this.NewMegaloPlayerTraits());
}
using (var bm = s.EnterCursorBookmarkOpt("UserDefinedOptions", UserDefinedOptions, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamableElements("entry", UserDefinedOptions);
}
if (!s.StreamAttributeOpt("engineIcon", ref EngineIconIndex, Predicates.IsNotNone))
{
EngineIconIndex = TypeExtensions.kNone;
}
if (!s.StreamAttributeOpt("engineCategory", ref EngineCategory, Predicates.IsNotNone))
{
EngineCategory = TypeExtensions.kNone;
}
using (var bm = s.EnterCursorBookmarkOpt("MapPermissions", MapPermissions, mp => !mp.IsDefault)) if (bm.IsNotNull)
{
s.StreamObject(MapPermissions);
}
using (var bm = s.EnterCursorBookmarkOpt("PlayerRatingParams", PlayerRatingParameters, prp => !prp.IsDefault)) if (bm.IsNotNull)
{
s.StreamObject(PlayerRatingParameters);
}
else
{
PlayerRatingParameters.RevertToDefault();
}
s.StreamAttributeOpt("scoreToWinRound", ref ScoreToWinRound, Predicates.IsNotZero);
SerializeOptionToggles(s);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
if (!s.StreamAttributeOpt("name", ref mCodeName, Predicates.IsNotNullOrEmpty))
{
mCodeName = "";
}
using (var bm = s.EnterCursorBookmarkOpt("String", this, obj => obj.JustEnglish)) if (bm.IsNotNull)
{
LanguageRegistry.CodeExpectsEnglishFirst();
int k_english_index = mLanguageTable.EnglishGameLangaugeHandle.GameIndex;
s.StreamCursor(ref mLanguageStrings[k_english_index]);
if (s.IsReading)
{
// empty cursor text returns null, at least in the XML implementation
if (mLanguageStrings[k_english_index] == null)
{
mLanguageStrings[k_english_index] = "";
}
for (int x = 1; x < mLanguageStrings.Length; x++)
{
mLanguageStrings[x] = mLanguageStrings[k_english_index];
}
}
}
else
{
SerializeLanguages(s);
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
bool reading = s.IsReading;
if (reading && mAction.Template != null)
{
SetBase(mAction.Template.Parameters);
}
s.StreamableElements("Param", mParams);
using (var bm = s.EnterCursorBookmarkOpt(kNameOverridesRootName, this, obj => !obj.HasNameOverrides)) if (bm.IsNotNull)
{
if (s.IsReading)
{
NameOverridesFromStream(s);
}
else if (s.IsWriting)
{
NameOverridesToStream(s);
}
}
if (reading)
{
Count += mParams.Count;
}
}
/* static void StreamDeclaredSystemsValue<TDoc, TCursor>(IO.TagElementStream<TDoc, TCursor, string> s,
* BlamEngine engine,
* ref string externsFile)
* where TDoc : class
* where TCursor : class
* {
* s.StreamAttributeOpt("externs", ref externsFile, Predicates.IsNotNullOrEmpty);
* }*/
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
Contract.Assert(s.Owner == null);
s.Owner = this;
using (s.EnterUserDataBookmark(this))
{
BuildRepository.Serialize(s);
using (var bm = s.EnterCursorBookmarkOpt("Systems", mSystemPrototypes, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamableElements("System",
mSystemPrototypes, this, StreamSystemPrototypeKey);
}
}
/* using (var bm = s.EnterCursorBookmarkOpt("Systems", mDeclaredSystems, Predicates.HasItems)) if (bm.IsNotNull)
* s.StreamElements("System", mDeclaredSystems, this,
* StreamSystemPrototypeKey, StreamDeclaredSystemsValue,
* _ctxt => null);*/
if (s.IsReading)
{
if (mSystemPrototypes.Count > 0)
{
mActiveSystems = new Dictionary <Values.KGuid, EngineSystemBase>(mSystemPrototypes.Count);
}
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (s.EnterUserDataBookmark(this))
{
s.StreamAttributeOpt("name", this, obj => EcfName, Predicates.IsNotNullOrEmpty);
s.StreamAttributeOpt("ext", this, obj => EcfFileExtension, Predicates.IsNotNullOrEmpty);
using (s.EnterCursorBookmark("Header"))
{
s.StreamAttribute("id", this, obj => HeaderId, NumeralBase.Hex);
s.StreamAttributeOpt("ChunkExtraDataSize", this, obj => ChunkExtraDataSize, Predicates.IsNotZero, NumeralBase.Hex);
}
using (var bm = s.EnterCursorBookmarkOpt("Chunks", Chunks, Predicates.HasItems))
s.StreamableElements("C", Chunks, obj => obj.HasPossibleFileData);
}
// #NOTE leaving this as an exercise for the caller instead, so they can yell when something is culled
#if false
if (s.IsReading)
{
CullChunksPossiblyWithoutFileData();
}
#endif
}
static void SerializeTargets <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (s.EnterCursorBookmark("Targets"))
{
using (var bm = s.EnterCursorBookmarkOpt("Platforms", gTargetPlatforms, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamableElements("Platform", gTargetPlatforms);
}
using (var bm = s.EnterCursorBookmarkOpt("ResourceModels", gResourceModels, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamElements("Model", gResourceModels);
}
}
}
public virtual void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (var bm = s.EnterCursorBookmarkOpt("Modifiers", this, obj => !obj.ModifiersAreUnchanged)) if (bm.IsNotNull)
{
SerializeModifiers(s);
}
}
protected override void SerializeLocaleStrings <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.SerializeLocaleStrings(s);
using (var bm = s.EnterCursorBookmarkOpt("IntroString", IntroDescriptionString, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamObject(IntroDescriptionString);
}
}
protected void SerializeGameObjectFilters <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (var bm = s.EnterCursorBookmarkOpt("GameObjectFilters", CandySpawnerFilters, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamableElements("Filter", CandySpawnerFilters);
}
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.Serialize(s);
using (var bm = s.EnterCursorBookmarkOpt("WeaponSkins", this, obj => !obj.WeaponSkinsAreUnchanged)) if (bm.IsNotNull)
{
s.StreamAttributeOpt("primary", ref PrimaryWeaponSkin, Predicates.IsNotZero);
s.StreamAttributeOpt("secondary", ref SecondaryWeaponSkin, Predicates.IsNotZero);
}
}
public virtual void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamAttributeEnumOpt("flags", ref Flags, f => f != 0, true);
using (var bm = s.EnterCursorBookmarkOpt("Lives", this, obj => !obj.LivesAreDefault)) if (bm.IsNotNull)
{
s.StreamAttribute("perRound", ref LivesPerRound);
s.StreamAttribute("perRoundTeam", ref TeamLivesPerRound);
}
using (s.EnterCursorBookmark("Times"))
SerializeTimes(s);
using (var bm = s.EnterCursorBookmarkOpt("Traits", Traits, obj => !obj.IsUnchanged)) if (bm.IsNotNull)
{
s.StreamAttributeOpt("duration", ref TraitsDuration, Predicates.IsNotZero);
s.StreamObject(Traits);
}
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.Serialize(s);
s.StreamAttributeOptUnchangedZero("directionalDamageIndicator", ref DirectionalDamageIndicator);
using (var bm = s.EnterCursorBookmarkOpt("MotionTracker", this, obj => !obj.MotionTrackerIsUnchanged)) if (bm.IsNotNull)
{
s.StreamAttributeOptUnchangedZero("usage", ref MotionTracker);
}
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.Serialize(s);
s.StreamAttributeOptUnchangedZero("doubleJump", ref DoubleJump);
using (var bm = s.EnterCursorBookmarkOpt("Usage", this, obj => !obj.UsageIsUnchanged)) if (bm.IsNotNull)
{
s.StreamAttributeOptUnchangedZero("vehicles", ref VehicleUsage);
}
}
protected override void SerializeImpl <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.SerializeImpl(s);
using (var bm = s.EnterCursorBookmarkOpt("Loadouts", Loadouts, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamableElements("entry", Loadouts);
}
s.StreamAttribute("unk1ACF2", ref unk1ACF2);
s.StreamAttribute("unk1ACF3", ref unk1ACF3);
s.StreamAttribute("unk1ACF4", ref unk1ACF4);
if (HasWeaponTuning)
{
using (var bm = s.EnterCursorBookmarkOpt("WeaponTuning", WeaponTuning, obj => !obj.IsUnchanged)) if (bm.IsNotNull)
{
WeaponTuning.Serialize(s);
}
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamAttributeOpt("playerRequisitionFrequencySeconds", ref PlayerRequisitionFrequencySeconds, Predicates.IsNotZero);
s.StreamAttributeOpt("initialGameCurrency", ref InitialGameCurrency, Predicates.IsNotZero);
using (var bm = s.EnterCursorBookmarkOpt("Items", RequisitionItems, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamableElements("entry", RequisitionItems);
}
}
protected virtual void SerializeImpl <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamAttributeEnumOpt("flags", ref Flags, flags => flags != 0, true);
s.StreamAttributeOpt("fireteamCount", ref FireteamCount, v => v != 1);
using (var bm = s.EnterCursorBookmarkOpt("Overrides", this, obj => !obj.OverridesAreDefault)) if (bm.IsNotNull)
{
SerializeOverrides(s);
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
using (var bm = s.EnterCursorBookmarkOpt(kXmlRoot)) if (bm.IsNotNull)
{
xs.StreamDBID(s, XML.XmlUtil.kNoXmlName, ref mDefaultShieldSquadID, DatabaseObjectKind.Squad, false, XML.XmlUtil.kSourceCursor);
XML.XmlUtil.Serialize(s, ProtoShieldIDs, BProtoSquadShieldBubble.kBListXmlParams);
}
}
void SerializeOptionToggles <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
#region EngineOptions
using (var bm = s.EnterCursorBookmarkOpt("EngineOptions", this, _obj => _obj.HasEngineOptionToggles)) if (bm.IsNotNull)
{
using (var bm2 = s.EnterCursorBookmarkOpt("Disabled", DisabledEngineOptions, Predicates.HasBits)) if (bm2.IsNotNull)
{
DisabledEngineOptions.Serialize(s, "Option", this, SerializeEngineOptionToggle);
}
using (var bm2 = s.EnterCursorBookmarkOpt("Hidden", HiddenEngineOptions, Predicates.HasBits)) if (bm2.IsNotNull)
{
HiddenEngineOptions.Serialize(s, "Option", this, SerializeEngineOptionToggle);
}
}
#endregion
#region UserOptions
using (var bm = s.EnterCursorBookmarkOpt("UserOptions", this, _obj => _obj.HasUserOptionToggles)) if (bm.IsNotNull)
{
using (var bm2 = s.EnterCursorBookmarkOpt("Disabled", DisabledUserOptions, Predicates.HasBits)) if (bm2.IsNotNull)
{
DisabledUserOptions.Serialize(s, "Option", this, SerializeUserOptionToggle);
}
using (var bm2 = s.EnterCursorBookmarkOpt("Hidden", HiddenUserOptions, Predicates.HasBits)) if (bm2.IsNotNull)
{
HiddenUserOptions.Serialize(s, "Option", this, SerializeUserOptionToggle);
}
}
#endregion
}
