public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamAttributeEnumOpt("LeftRumbleType", ref mLeftRumbleType, e => e != BRumbleType.None);
s.StreamAttributeEnumOpt("RightRumbleType", ref mRightRumbleType, e => e != BRumbleType.None);
s.StreamAttributeOpt("Duration", ref mDuration, Predicates.IsNotZero);
s.StreamAttributeOpt("LeftStrength", ref mLeftStrength, Predicates.IsNotZero);
s.StreamAttributeOpt("RightStrength", ref mRightStrength, Predicates.IsNotZero);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var teamChanging = s.IsReading ? TeamChangingType.Enabled : (TeamChangingType)TeamChanging;
//s.StreamAttributeOpt("observersAllowed", ref ObserversAllowed, Predicates.IsTrue);
s.StreamAttributeEnumOpt("teamChanging", ref teamChanging, v => v != TeamChangingType.Enabled);
s.StreamAttributeEnumOpt("flags", ref Flags, flags => flags != kDefaultFlags, true);
if (s.IsReading)
{
TeamChanging = (byte)teamChanging;
}
}
protected virtual void SerializeImpl <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (s.EnterCursorBookmark("Sandbox"))
{
s.StreamAttributeEnumOpt("flags", ref Flags, flags => flags != GameEngineSandboxVariantFlags.OpenChannelVoiceEnabled, true);
s.StreamAttributeEnumOpt("editMode", ref EditMode, e => e != SandboxEditingMode.AllPlayers);
s.StreamAttributeEnumOpt("respawnTime", ref RespawnTime, v => v != TypeExtensionsBlam.kUsualDefaultRespawnTimeInSeconds);
using (var bm = s.EnterCursorBookmarkOpt("EditorTraits", EditorTraits, obj => !obj.IsUnchanged)) if (bm.IsNotNull)
{
EditorTraits.Serialize(s);
}
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var model = (Model.MegaloScriptModel)s.Owner;
model.MegaloVariant.SerializeStringTableIndexOpt(s, "labelIndex", ref mLabelStringIndex);
SerializeCodeName(s);
s.StreamAttributeEnumOpt("params", ref mValidParameters, f => f != 0, true);
s.StreamAttributeOpt("min", ref mMinimum, Predicates.IsNotZero);
if (HasObjectTypeIndex)
{
Model.MegaloScriptIndexValue.SerializeValue(model, s, model.Database.ObjectTypeIndexValueType,
ref mObjectTypeIndex, IO.TagElementNodeType.Element, "ObjectType");
}
if (HasTeam)
{
Model.MegaloScriptEnumValue.SerializeValue(model, s, model.Database.TeamDesignatorValueType,
ref mTeam, IO.TagElementNodeType.Element, "Team");
}
if (HasNumeric)
{
s.StreamElement("Numeric", ref mNumeric);
}
}
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
{
s.StreamAttributeOpt("designatorSwitchType", ref DesignatorSwitchType, v => v != 2);
s.StreamAttributeEnumOpt("model", ref ModelOverride, e => e != GameOptionsTeamOptionsModelOverride.Default);
SerializeTeams(s);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamCursorEnum(ref mType);
s.StreamAttributeEnumOpt("target", ref mTarget, e => e != BCollectibleSkullTarget.None);
s.StreamAttributeOpt("value", ref mValue, PhxPredicates.IsNotInvalid);
}
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 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);
s.StreamAttributeOptNoneOption("nameIndex", ref NameIndex);
SerializeWeaponsAndEquipment(s);
s.StreamAttributeOpt("grenadeCount", ref InitialGrenadeCount, Predicates.IsNotZero);
}
// #NOTE the attributes here should match the ones used in EcfChunk's code
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var ecf_expander = s.Owner as EcfFileExpander;
if (s.IsReading)
{
Parent = (EcfFileDefinition)s.UserData;
}
s.StreamAttribute("id", this, obj => Id, NumeralBase.Hex);
s.StreamAttributeOpt("align", this, obj => AlignmentBit, b => b != EcfChunk.kDefaultAlignmentBit, NumeralBase.Hex);
if (s.StreamAttributeEnumOpt("Compression", this, obj => CompressionType, e => e != EcfCompressionType.Stored))
{
// #NOTE DeflateRaw requires the decompressed size to be known somewhere, and generic ECF files do not store such info
// Only available in ERAs
if (CompressionType == EcfCompressionType.DeflateRaw)
{
s.ThrowReadException(new InvalidDataException(CompressionType + " is not supported in this context"));
}
}
if (s.IsReading)
{
ReadResourceFlags(s);
}
else if (s.IsWriting)
{
WriteResourceFlags(s);
}
s.StreamAttributeOpt("Path", this, obj => FilePath, Predicates.IsNotNullOrEmpty);
// Don't try to write the file bytes
bool try_to_serialize_file_bytes = s.IsReading || FilePath.IsNullOrEmpty();
if (ecf_expander != null)
{
if (!ecf_expander.ExpanderOptions.Test(EcfFileExpanderOptions.DontSaveChunksToFiles))
{
try_to_serialize_file_bytes = true;
}
}
if (try_to_serialize_file_bytes)
{
if (!s.StreamCursorBytesOpt(this, obj => FileBytes))
{
if (FilePath.IsNullOrEmpty())
{
s.ThrowReadException(new InvalidDataException("Expect Path attribute or file hex bytes"));
}
}
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
s.StreamAttributeEnumOpt("status", ref mTechStatus, BProtoTechStatusIsNotInvalid);
xs.StreamDBID(s, XML.XmlUtil.kNoXmlName, ref mTechID, DatabaseObjectKind.Tech, false, XML.XmlUtil.kSourceCursor);
}
protected virtual void SerializeOverrides <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamAttributeOpt("primaryColor", ref PrimaryColorOverride, v => v != uint.MaxValue, NumeralBase.Hex);
s.StreamAttributeOpt("secondaryColor", ref SecondaryColorOverride, v => v != uint.MaxValue, NumeralBase.Hex);
s.StreamAttributeOpt("textColor", ref TextColorOverride, v => v != uint.MaxValue, NumeralBase.Hex);
s.StreamAttributeEnumOpt("model", ref ModelOverride, e => e != GameOptionsSingleTeamModelOverride.Spartan);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
s.StreamAttribute("count", ref mCount);
s.StreamAttributeEnumOpt("role", ref mUnitRole, e => e != BUnitRole.Normal);
xs.StreamDBID(s, XML.XmlUtil.kNoXmlName, ref mUnitID, DatabaseObjectKind.Object, false, XML.XmlUtil.kSourceCursor);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
xs.StreamDBID(s, "unit", ref mUnitID, DatabaseObjectKind.Object, false, XML.XmlUtil.kSourceAttr);
s.StreamAttributeEnumOpt("operator", ref mOperator, e => e != BProtoTechTypeCountOperator.e);
s.StreamAttributeOpt("count", ref mCount, Predicates.IsNotZero);
}
public void StreamCommand <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s, XML.BXmlSerializerInterface xs)
where TDoc : class
where TCursor : class
{
// #NOTE engine parses this as "CommandType", but its parser ignores case
if (s.StreamAttributeEnumOpt("commandType", ref CommandType, e => e != BProtoObjectCommandType.Invalid))
{
StreamCommandData(s, xs);
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
xs.StreamDBID(s, XML.XmlUtil.kNoXmlName, ref mDamageType, DatabaseObjectKind.DamageType, isOptional: false, xmlSource: XML.XmlUtil.kSourceCursor);
s.StreamAttributeEnum("direction", ref mDirection);
s.StreamAttributeEnumOpt("mode", ref mMode, e => e != BSquadMode.Normal);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamAttributeOpt("sizeX", ref mSize.X, f => f != 2.0f);
s.StreamAttributeOpt("sizeZ", ref mSize.Z, f => f != 2.0f);
s.StreamAttributeOpt("timeFullyOpaque", ref mTimeFullyOpaque, f => f != 5.0f);
s.StreamAttributeOpt("fadeOutTime", ref mFadeOutTime, f => f != 10.0f);
s.StreamAttributeEnumOpt("orientation", ref mOrientation, e => e != OrientationType.Random);
s.StreamCursor(ref mTextureName);
}
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);
}
}
// #NOTE_BLAM: up to concrete implementations to serialize References
public override void Serialize <TDoc, TCursor>(MegaloScriptModel model, IO.TagElementStream <TDoc, TCursor, string> s)
{
SerializeIdOpt(model, s);
s.StreamAttributeEnumOpt("trigType", ref mTriggerType, e => e != MegaloScriptTriggerType.Normal);
s.StreamAttributeEnumOpt("execMode", ref mExecutionMode, e => e != MegaloScriptTriggerExecutionMode.General);
SerializeNameOpt(s);
if (ExecutionMode == MegaloScriptTriggerExecutionMode.OnObjectFilter)
{
s.StreamAttributeIdAsString("objectFilter", ref mObjectFilterIndex, model,
(_model, name) => model.FromIndexName(Proto.MegaloScriptValueIndexTarget.ObjectFilter, name),
(_model, id) => model.ToIndexName(Proto.MegaloScriptValueIndexTarget.ObjectFilter, id));
}
else
{
ObjectFilterIndex = -1;
}
if (ExecutionMode == MegaloScriptTriggerExecutionMode.OnCandySpawnerFilter)
{
using (s.EnterCursorBookmark("GameObject"))
{
s.StreamAttributeEnum("type", ref mGameObjectType);
s.StreamAttributeIdAsString("filter", ref mGameObjectFilterIndex, model,
(_model, name) => model.FromIndexName(Proto.MegaloScriptValueIndexTarget.GameObjectFilter, name),
(_model, id) => model.ToIndexName(Proto.MegaloScriptValueIndexTarget.GameObjectFilter, id));
}
}
else
{
GameObjectFilterIndex = -1;
}
if (TriggerType == MegaloScriptTriggerType.Normal)
{
s.StreamAttributeOpt("commentOut", ref mCommentOut, Predicates.IsTrue);
}
}
public virtual void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var model = (MegaloScriptModel)s.Owner;
model.MegaloVariant.SerializeStringTableIndexOpt(s, "nameIndex", ref mNameStringIndex);
s.StreamAttributeEnum("format", ref mFormat);
s.StreamAttributeEnumOpt("sortOrder", ref mSortOrder, e => e != MegaloScriptGameStatisticSortOrder.Ascending);
s.StreamAttributeEnumOpt("grouping", ref mGrouping, e => e != 0);
SerializeCodeName(s);
if (SupportsUnk5)
{
s.StreamAttributeOpt("unk5", ref mUnk5, Predicates.IsTrue);
}
if (SupportsIsScoreToWin)
{
s.StreamAttributeOpt("isScoreToWin", ref mIsScoreToWin, Predicates.IsTrue);
}
}
protected override void SerializeValue <TDoc, TCursor>(MegaloScriptModel model, IO.TagElementStream <TDoc, TCursor, string> s)
{
if (!s.StreamAttributeEnumOpt("iconType", ref mIconType, e => e != MegaloScriptNavpointIconType.None))
{
mIconType = MegaloScriptNavpointIconType.None;
}
if (mIconType == MegaloScriptNavpointIconType.Territory)
{
using (s.EnterCursorBookmark("TerritoryDesignator"))
mNumeric.SerializeCustom(model, s);
}
}
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 (s.EnterCursorBookmark("Round"))
{
s.StreamAttribute("timeLimit", ref RoundTimeLimit);
s.StreamAttribute("limit", ref RoundLimit);
s.StreamAttribute("earlyVictoryWinCount", ref EarlyVictoryWinCount);
s.StreamAttribute("suddenDeathTimeLimit", ref SuddenDeathTimeLimit);
}
}
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);
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
s.StreamCursor(ref mSound);
if (s.StreamAttributeEnumOpt("Type", ref mType, e => e != BObjectSoundType.None))
{
xs.StreamDBID(s, "Squad", ref mSquadID, DatabaseObjectKind.Squad, xmlSource: XML.XmlUtil.kSourceAttr);
s.StreamAttributeOpt("Action", ref mAction, Predicates.IsNotNullOrEmpty);
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
s.StreamAttributeEnumOpt("Type", ref mType, e => e != ChildObjectType.Object);
xs.StreamDBID(s, XML.XmlUtil.kNoXmlName, ref mID, TypeObjectKind, isOptional: false, xmlSource: XML.XmlUtil.kSourceCursor);
s.StreamAttributeOpt("AttachBone", ref mAttachBone, Predicates.IsNotNullOrEmpty);
s.StreamBVector("Offset", ref mOffset, xmlSource: XML.XmlUtil.kSourceAttr);
s.StreamAttributeOpt("Rotation", ref mRotation, Predicates.IsNotZero);
xs.StreamDBID(s, "UserCiv", ref mUserCivID, DatabaseObjectKind.Civ, xmlSource: XML.XmlUtil.kSourceAttr);
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
s.StreamAttributeEnumOpt("flags", ref Flags, flags => flags != 0, true);
SerializeContentHeader(s);
SerializeMiscOptions(s);
SerializRespawnOptions(s);
SerializeSocialOptions(s);
SerializMapOverrides(s);
SerializeTeams(s);
SerializeLoadoutOptions(s);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamAttribute("_locID", ref mID);
s.StreamAttributeEnumOpt("category", ref mCategory, e => e != LocStringCategory.None);
s.StreamAttributeOpt("scenario", ref mScenario, Predicates.IsNotNullOrEmpty);
s.StreamAttributeOpt("subtitle", ref mIsSubtitle, Predicates.IsTrue);
s.StreamAttributeOpt("Update", ref mIsUpdate, Predicates.IsTrue);
s.StreamAttributeOpt("_mouseKeyboard", ref mMouseKeyboardID, Predicates.IsNotNone);
s.StreamAttributeOpt("originally", ref mOriginalID, Predicates.IsNotNullOrEmpty);
if (s.IsReading || mText.IsNotNullOrEmpty())
{
s.StreamCursor(ref mText);
}
}
protected virtual void Serialize <TDoc, TCursor>(MegaloScriptModel model, IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
if (HasNetworkState)
{
s.StreamAttributeEnumOpt("networkState", ref mNetworkState, e => e != MegaloScriptVariableNetworkState.Local);
}
SerializeCodeName(s);
if (SupportsUnknown)
{
s.StreamAttributeOpt("unknown", ref mUnknown, Predicates.IsTrue);
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var db = s.Owner as MegaloScriptDatabase;
bool reading = s.IsReading;
//string type_name = reading ? null : db.ValueTypeNames[Type.NameIndex];
s.StreamAttributeOpt(kSigIdAttributeName, ref SigId, Predicates.IsNotZero);
db.SerializeValueTypeReference(s, kTypeAttributeName, ref Type);
if (!s.StreamAttributeOpt(kNameAttirbuteName, ref Name, Predicates.IsNotNullOrEmpty) &&
reading)
{
Name = string.Format("Param{0}", SigId.ToString());
}
s.StreamAttributeEnumOpt(kKindAttributeName, ref Kind);
s.StreamAttributeOpt("optional", ref Optional, Predicates.IsTrue);
}
public 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);
s.StreamAttributeOpt("PrecisionWeaponReticuleBloom", ref PrecisionWeaponBloom, f => f != 1.0f);
if (s.StreamElementOpt("ArmorLockDamageToEnergyTransfer", ref ArmorLockDamageToEnergyTransfer, f => f != 0.0f))
{
s.WriteComment("Damage received while in Armor Lock is transferred to remaining Armor Ability energy");
}
s.StreamElementOpt("ArmorLockDamageToEnergyCap", ref ArmorLockDamageToEnergyCap, f => f != 0.0f);
s.StreamElementOpt("ActiveCamoOverrideEnergyCurveMin", ref ActiveCamoOverrideEnergyCurveMin, f => f != 0.02f);
s.StreamElementOpt("ActiveCamoOverrideEnergyCurveMax", ref ActiveCamoOverrideEnergyCurveMax, f => f != 0.07f);
s.StreamAttributeOpt("MagnumDamageMultiplier", ref MagnumDamageMultiplier, f => f != 1.0f);
s.StreamAttributeOpt("MagnumFireRecoveryTimeMultiplier", ref MagnumFireRecoveryTimeMultiplier, f => f != 1.0f);
}
