public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
var td = KSoft.Debug.TypeCheck.CastReference <BTacticData>(s.UserData);
s.StreamElementEnumOpt("Relation", ref mRelation, e => e != BRelationType.Enemy);
if (!s.StreamElementEnumOpt("SquadMode", ref mSquadMode, e => e != BSquadMode.Invalid))
{
if (s.StreamElementEnumOpt("AutoTargetSquadMode", ref mSquadMode, e => e != BSquadMode.Invalid))
{
AutoTargetSquadMode = true;
}
}
s.StreamElements("DamageType", DamageTypes, xs, XML.BDatabaseXmlSerializerBase.StreamDamageType);
s.StreamElements("TargetType", TargetTypes, xs, XML.BDatabaseXmlSerializerBase.StreamUnitID);
td.StreamID(s, "Action", ref mActionID, TacticDataObjectKind.Action);
XML.XmlUtil.Serialize(s, Flags, XML.BBitSetXmlParams.kFlagsAreElementNamesThatMeanTrue);
XML.XmlUtil.Serialize(s, TargetStates, kTargetStatesXmlParams);
if (!xs.StreamDBID(s, "Ability", ref mAbilityID, DatabaseObjectKind.Ability))
{
IsOptionalAbility = xs.StreamDBID(s, "OptionalAbility", ref mAbilityID, DatabaseObjectKind.Ability);
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
bool should_stream = true;
string root_name = Params.GetOptionalRootName();
var xs = s.GetSerializerInterface();
if (s.IsReading) // If the stream doesn't have the expected element, don't try to stream
{
should_stream = root_name == null || s.ElementsExists(root_name);
}
else if (s.IsWriting)
{
should_stream = List != null && List.IsEmpty == false;
}
if (should_stream)
{
using (s.EnterCursorBookmark(root_name))
{
if (s.IsReading)
{
ReadNodes(s, xs);
}
else if (s.IsWriting)
{
WriteNodes(s, xs);
}
}
}
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.Serialize(s);
var xs = s.GetSerializerInterface();
s.StreamElementEnumOpt("Type", ref mType, e => e != BAbilityType.Invalid);
s.StreamElementOpt("AmmoCost", ref mAmmoCost, Predicates.IsNotZero);
s.StreamElements("Object", ObjectIDs, xs, XML.BDatabaseXmlSerializerBase.StreamObjectID);
s.StreamElementEnumOpt("SquadMode", ref mSquadMode, e => e != BSquadMode.Invalid);
s.StreamElementEnumOpt("RecoverStart", ref mRecoverStart, e => e != BRecoverType.Move);
s.StreamElementEnumOpt("RecoverType", ref mRecoverType, e => e != BRecoverType.Move);
s.StreamElementOpt("RecoverTime", ref mRecoverTime, Predicates.IsNotZero);
s.StreamElementOpt("MovementSpeedModifier", ref mMovementSpeedModifier, Predicates.IsNotZero);
s.StreamElementEnumOpt("MovementModifierType", ref mMovementModifierType, e => e != BMovementModifierType.Mode);
s.StreamElementOpt("DamageTakenModifier", ref mDamageTakenModifier, Predicates.IsNotZero);
s.StreamElementOpt("DodgeModifier", ref mDodgeModifier, Predicates.IsNotZero);
s.StreamStringOpt("Icon", ref mIcon, toLower: false, type: XML.XmlUtil.kSourceElement);
s.StreamElementEnumOpt("TargetType", ref mTargetType, e => e != BAbilityTargetType.None);
s.StreamStringOpt("RecoverAnimAttachment", ref mRecoverAnimAttachment, toLower: false, type: XML.XmlUtil.kSourceElement);
s.StreamStringOpt("RecoverStartAnim", ref mRecoverStartAnim, toLower: false, type: XML.XmlUtil.kSourceElement);
s.StreamStringOpt("RecoverEndAnim", ref mRecoverEndAnim, toLower: false, type: XML.XmlUtil.kSourceElement);
s.StreamElementOpt("Sprinting", ref mSprinting, Predicates.IsTrue);
s.StreamElementOpt("DontInterruptAttack", ref mDontInterruptAttack, Predicates.IsTrue);
s.StreamElementOpt("KeepSquadMode", ref mKeepSquadMode, Predicates.IsTrue);
s.StreamElementOpt("AttackSquadMode", ref mAttackSquadMode, Predicates.IsTrue);
s.StreamElementOpt("Duration", ref mDuration, Predicates.IsNotZero);
s.StreamElementOpt("SmartTargetRange", ref mSmartTargetRange, v => v != cDefaultSmartTargetRange);
s.StreamElementOpt("CanHeteroCommand", ref mCanHeteroCommand, Predicates.IsFalse);
s.StreamElementOpt("NoAbilityReticle", ref mNoAbilityReticle, Predicates.IsTrue);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
XML.XmlUtil.Serialize(s, Data, BProtoPowerData.kBListXmlParams);
}
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 mToMergeSquadID, DatabaseObjectKind.Squad, false, XML.XmlUtil.kSourceCursor);
s.StreamElements("MergedSquad", BaseSquadIDs, xs, XML.BDatabaseXmlSerializerBase.StreamSquadID);
}
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 void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
xs.StreamDBID(s, "type", ref mUnitTypeID, DatabaseObjectKind.Unit, false, XML.XmlUtil.kSourceAttr);
s.StreamCursor(ref mPriority);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
xs.StreamDBID(s, "ObjectType", ref mObjectType, DatabaseObjectKind.ObjectType, isOptional: false, xmlSource: XML.XmlUtil.kSourceAttr);
s.StreamCursor(ref mEffectiveness);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
xs.StreamDBID(s, "target", ref mTargetSquadID, DatabaseObjectKind.Squad, false, XML.XmlUtil.kSourceAttr);
xs.StreamDBID(s, XML.XmlUtil.kNoXmlName, ref mShieldSquadID, DatabaseObjectKind.Squad, 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();
s.StreamAttributeEnum("type", ref mType);
StreamValueID(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, "civ", ref mCivID, DatabaseObjectKind.Civ, true, XML.XmlUtil.kSourceAttr);
xs.StreamStringID(s, XML.XmlUtil.kNoXmlName, ref mTextID, XML.XmlUtil.kSourceCursor);
}
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);
}
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, 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
{
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 Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
s.StreamAttribute("IconLocation", ref mIconLocation);
xs.StreamDBID(s, "Power", SupportPowerIDs, DatabaseObjectKind.Power, isOptional: false, xmlSource: XML.XmlUtil.kSourceCursor);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
if (HasNameID)
{
xs.StreamStringID(s, "NameID", ref mNameID);
}
if (HasDisplayNameID)
{
xs.StreamStringID(s, "DisplayNameID", ref mDisplayNameID);
}
if (HasDisplayName2ID)
{
xs.StreamStringID(s, "DisplayName2ID", ref mDisplayName2ID);
}
if (HasDescriptionID)
{
xs.StreamStringID(s, "DescriptionID", ref mDescriptionID);
}
if (HasLongDescriptionID)
{
xs.StreamStringID(s, "LongDescriptionID", ref mLongDescriptionID);
}
if (HasPrereqTextID)
{
xs.StreamStringID(s, "PrereqTextID", ref mPrereqTextID);
}
if (HasRoleTextID)
{
xs.StreamStringID(s, "RoleTextID", ref mRoleTextID);
}
if (HasRolloverTextID)
{
xs.StreamStringID(s, "RolloverTextID", ref mRolloverTextID);
}
if (HasEnemyRolloverTextID)
{
xs.StreamStringID(s, "EnemyRolloverTextID", ref mEnemyRolloverTextID);
}
if (HasGaiaRolloverTextID)
{
XML.XmlUtil.Serialize(s, GaiaRolloverText, GaiaRolloverTextData.kBListXmlParams);
}
if (HasStatsNameID)
{
xs.StreamStringID(s, "StatsNameID", ref mStatsNameID);
}
if (HasChooseTextID)
{
xs.StreamStringID(s, "ChooseTextID", ref mChooseTextID);
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
s.StreamBVector("Offset", ref mOffset, xmlSource: XML.XmlUtil.kSourceAttr);
s.StreamAttributeOpt("FlyIn", ref mFlyIn, Predicates.IsTrue);
XML.BXmlSerializerInterface.StreamSquadID(s, xs, ref mSquadID);
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
var xs = s.GetSerializerInterface();
s.StreamAttribute("objectdbid", ref mObjectDBID);
XML.XmlUtil.Serialize(s, Effects, BCollectibleSkullEffect.kBListXmlParams);
s.StreamElementOpt("DisplayImageOn", ref mDisplayImageOn, Predicates.IsNotNullOrEmpty);
s.StreamElementOpt("DisplayImageOff", ref mDisplayImageOff, Predicates.IsNotNullOrEmpty);
s.StreamElementOpt("DisplayImageLocked", ref mDisplayImageLocked, Predicates.IsNotNullOrEmpty);
s.StreamElementNamedFlag("Hidden", ref mHidden);
}
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 ReadNodes <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
Collections.IProtoEnum penum = Bits.InitializeFromEnum(xs.Database);
if (Params.ElementItselfMeansTrue)
{
var getDefault = Bits.Params.kGetMemberDefaultValue;
foreach (var e in s.Elements)
{
var element_name = s.GetElementName(e);
int id = penum.TryGetMemberId(element_name);
if (id.IsNone())
{
continue;
}
bool flag = true;
s.StreamElementOpt(element_name, ref flag);
if (getDefault != null && flag != getDefault(id))
{
// do nothing, allow the Set call below
}
else if (!flag)
{
continue;
}
Bits.Set(id, flag);
}
}
else
{
foreach (var n in s.ElementsByName(Params.ElementName))
{
using (s.EnterCursorBookmark(n))
{
string name = null;
Params.StreamDataName(s, ref name);
int id = penum.GetMemberId(name);
Bits.Set(id);
}
}
}
Bits.OptimizeStorage();
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
xs.StreamDBID(s, "base", ref mBaseObjectID, DatabaseObjectKind.Object, false, XML.XmlUtil.kSourceAttr);
xs.StreamDBID(s, "infected", ref mInfectedObjectID, DatabaseObjectKind.Object, false, XML.XmlUtil.kSourceAttr);
if (xs.Database.Engine.Build != Engine.PhxEngineBuild.Alpha)
{
xs.StreamDBID(s, "infectedSquad", ref mInfectedSquadID, DatabaseObjectKind.Squad, false, XML.XmlUtil.kSourceAttr);
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
s.StreamBVector("Offset", ref mOffset, xmlSource: XML.XmlUtil.kSourceAttr);
xs.StreamDBID(s, XML.XmlUtil.kNoXmlName, ref mObjectTypeID, DatabaseObjectKind.Object, false, XML.XmlUtil.kSourceCursor);
xs.StreamDBID(s, "BuildOther", ref mBuildOtherID, DatabaseObjectKind.Object, xmlSource: XML.XmlUtil.kSourceAttr);
s.StreamAttributeOpt("DoppleOnStart", ref mDoppleOnStart, Predicates.IsTrue);
}
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 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.StreamAttributeEnum("type", ref mDataType);
s.StreamAttribute("name", ref mName);
switch (DataType)
{
case ProtoPowerDataType.Float:
s.StreamCursor(ref mDataFloat);
break;
case ProtoPowerDataType.Int:
s.StreamCursor(ref mDataInt);
break;
case ProtoPowerDataType.ProtoObject:
xs.StreamDBID(s, XML.XmlUtil.kNoXmlName, ref mDataInt, DatabaseObjectKind.Object, isOptional: false, xmlSource: XML.XmlUtil.kSourceCursor);
break;
case ProtoPowerDataType.ProtoSquad:
xs.StreamDBID(s, XML.XmlUtil.kNoXmlName, ref mDataInt, DatabaseObjectKind.Squad, isOptional: false, xmlSource: XML.XmlUtil.kSourceCursor);
break;
case ProtoPowerDataType.Tech:
xs.StreamDBID(s, XML.XmlUtil.kNoXmlName, ref mDataInt, DatabaseObjectKind.Tech, isOptional: false, xmlSource: XML.XmlUtil.kSourceCursor);
break;
case ProtoPowerDataType.ObjectType:
xs.StreamDBID(s, XML.XmlUtil.kNoXmlName, ref mDataInt, DatabaseObjectKind.ObjectType, isOptional: false, xmlSource: XML.XmlUtil.kSourceCursor);
break;
case ProtoPowerDataType.Bool:
s.StreamCursor(ref mDataBool);
break;
case ProtoPowerDataType.Sound:
s.StreamCursor(ref mDataString);
break;
case ProtoPowerDataType.Texture:
s.StreamCursor(ref mDataString);
break;
}
//xs.StreamDBID(s, "ObjectType", ref mObjectType, DatabaseObjectKind.ObjectType, isOptional: false, xmlSource: XML.XmlUtil.kSourceAttr);
}
public void Serialize<TDoc, TCursor>(IO.TagElementStream<TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var xs = s.GetSerializerInterface();
xs.StreamDBID(s, "Civ", ref mCivID, DatabaseObjectKind.Civ, xmlSource: XML.XmlUtil.kSourceAttr);
if (!xs.StreamTypeName(s, BResource.kBListTypeValuesXmlParams_Cost.DataName, ref mResourceType, GameDataObjectKind.Cost, isOptional: false, xmlSource: XML.XmlUtil.kSourceAttr))
s.ThrowReadException(new System.IO.InvalidDataException(string.Format(
"ProtoObject's {0} XML doesn't define a {1}",
kBListXmlParams.ElementName, BResource.kBListTypeValuesXmlParams_Cost.DataName)));
s.StreamCursor(ref mCost);
}
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 != BSquadSoundType.None))
{
// #NOTE Engine, in debug builds, asserts Squad is valid when specified
xs.StreamDBID(s, "Squad", ref mSquadID, DatabaseObjectKind.Squad, xmlSource: XML.XmlUtil.kSourceAttr);
// #NOTE Engine, in debug builds, asserts the world ID is not cWorldIdNone when the World value is defined.
// It doesn't explicitly parse None, but defaults to None when it doesn't recognize the provided value
s.StreamProtoEnum("World", ref mWorldID, xs.Database.GameScenarioWorlds, xmlSource: XML.XmlUtil.kSourceAttr
, isOptionalDefaultValue: cWorldIdNone);
s.StreamAttributeOpt("CastingUnitOnly", ref mCastingUnitOnly, Predicates.IsTrue);
}
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
var xs = s.GetSerializerInterface();
s.StreamElementOpt("DamagePerSecond", ref mDamagePerSecond, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("DOTrate", ref mDOTRate, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("DOTduration", ref mDOTDuration, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("AttackRate", ref mAttackRate, PhxPredicates.IsNotInvalid);
xs.StreamDBID(s, "Projectile", ref mProjectileObjectID, DatabaseObjectKind.Object);
xs.StreamDBID(s, "WeaponType", ref mWeaponTypeID, DatabaseObjectKind.WeaponType);
s.StreamElementOpt("VisualAmmo", ref mVisualAmmo, Predicates.IsNotNone);
//TriggerScript
s.StreamElementOpt("MinRange", ref mMinRange, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("MaxRange", ref mMaxRange, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("ReflectDamageFactor", ref mReflectDamageFactor, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("MovingAccuracy", ref mMovingAccuracy, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("MaxDeviation", ref mMaxDeviation, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("MovingMaxDeviation", ref mMovingMaxDeviation, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("AccuracyDistanceFactor", ref mAccuracyDistanceFactor, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("AccuracyDeviationFactor", ref mAccuracyDeviationFactor, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("MaxVelocityLead", ref mMaxVelocityLead, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("AirBurstSpan", ref mAirBurstSpan, PhxPredicates.IsNotInvalid);
XML.XmlUtil.Serialize(s, DamageOverrides, BDamageRatingOverride.kBListXmlParams);
XML.XmlUtil.Serialize(s, TargetPriorities, BTargetPriority.kBListXmlParams);
using (var bm = s.EnterCursorBookmarkOpt("Stasis", this, o => o.mStasisSmartTargeting)) if (bm.IsNotNull)
{
s.StreamAttribute("SmartTargeting", ref mStasisSmartTargeting);
}
s.StreamElementOpt("StasisHealToDrainRatio", ref mStasisHealToDrainRatio, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("Bounces", ref mBounces, Predicates.IsNotNone);
s.StreamElementOpt("BounceRange", ref mBounceRange, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("MaxPullRange", ref mMaxPullRange, PhxPredicates.IsNotInvalid);
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.Serialize(s);
var xs = s.GetSerializerInterface();
s.StreamAttributeOpt("Alpha", ref mAlpha, Predicates.IsNotNone);
xs.StreamDBID(s, "CivTech", ref mTechID, DatabaseObjectKind.Tech);
xs.StreamDBID(s, "CommandAckObject", ref mCommandAckObjectID, DatabaseObjectKind.Object);
xs.StreamDBID(s, "RallyPointObject", ref mRallyPointObjectID, DatabaseObjectKind.Object);
xs.StreamDBID(s, "LocalRallyPointObject", ref mLocalRallyPointObjectID, DatabaseObjectKind.Object);
xs.StreamDBID(s, "Transport", ref mTransportObjectID, DatabaseObjectKind.Object);
xs.StreamDBID(s, "TransportTrigger", ref mTransportTriggerObjectID, DatabaseObjectKind.Object);
s.StreamElementOpt("ExpandHull", ref mHullExpansionRadius, Predicates.IsNotZero);
s.StreamElementOpt("TerrainPushOff", ref mTerrainPushOffRadius, Predicates.IsNotZero);
s.StreamElementOpt("BuildingMagnetRange", ref mBuildingMagnetRange, Predicates.IsNotZero);
s.StreamStringOpt("SoundBank", ref mSoundBank, toLower: false, type: XML.XmlUtil.kSourceElement);
xs.StreamStringID(s, "LeaderMenuNameID", ref mLeaderMenuNameID);
s.StreamElementOpt("PowerFromHero", ref mPowerFromHero, Predicates.IsTrue);
s.StreamStringOpt("UIControlBackground", ref mUIControlBackground, toLower: false, type: XML.XmlUtil.kSourceElement);
}
