public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.Serialize(s);
XML.XmlUtil.Serialize(s, ResourceCost, mResourceCostXmlParams);
s.StreamElementOpt("BuildPoints", ref mBuildTime, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("ResearchPoints", ref mResearchTime, PhxPredicates.IsNotInvalid);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamCursor(ref mAttachmentName);
s.StreamElementOpt("Hitpoints", ref mHitpoints, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("Shieldpoints", ref mShieldpoints, PhxPredicates.IsNotInvalid);
}
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
{
s.StreamElementOpt("CollectiblesXMLVersion", ref mXmlVersion, Predicates.IsNotNone);
SkullManager.Serialize(s);
}
public bool StreamStringID <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s, string xmlName,
ref int value, IO.TagElementNodeType xmlSource = XmlUtil.kSourceElement)
where TDoc : class
where TCursor : class
{
Contract.Requires(xmlSource.RequiresName() == (xmlName != XML.XmlUtil.kNoXmlName));
bool was_streamed = false;
if (xmlSource == XmlUtil.kSourceElement)
{
was_streamed = s.StreamElementOpt(xmlName, ref value, Predicates.IsNotNone);
}
else if (xmlSource == XmlUtil.kSourceAttr)
{
was_streamed = s.StreamAttributeOpt(xmlName, ref value, Predicates.IsNotNone);
}
else if (xmlSource == XmlUtil.kSourceCursor)
{
was_streamed = true;
s.StreamCursor(ref value);
}
if (s.IsReading)
{
if (value.IsNotNone())
{
Database.AddStringIDReference(value);
}
}
return(was_streamed);
}
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);
}
public void Serialize<TDoc, TCursor>(IO.TagElementStream<TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamAttributeEnum("type", ref Type);
SerializeActivity(s, "activity", ref Activity);
s.StreamAttributeEnum("mode", ref Mode);
s.StreamAttributeEnum("engine", ref EngineType);
s.StreamAttributeOpt("fileLength", ref FileLength, Predicates.IsNotZero);
using (s.EnterCursorBookmark("Unknown"))
{
s.StreamAttributeOpt("id0", ref unk08, Predicates.IsNotZero, NumeralBase.Hex);
s.StreamAttributeOpt("id1", ref unk10, Predicates.IsNotZero, NumeralBase.Hex);
s.StreamAttributeOpt("id2", ref unk18, Predicates.IsNotZero, NumeralBase.Hex);
s.StreamAttributeOpt("unk20", ref unk20, Predicates.IsNotZero, NumeralBase.Hex);
s.StreamAttributeOpt("unk2C", ref unk2C, Predicates.IsNotNone);
}
using (s.EnterCursorBookmark("Creator"))
s.StreamObject(Creator);
using (s.EnterCursorBookmark("Modifier"))
s.StreamObject(Modifier);
s.StreamElement("Title", ref Title);
s.StreamElementOpt("Description", ref Description, Predicates.IsNotNullOrEmpty);
if (Type == ContentType.Film || Type == ContentType.FilmClip)
s.StreamElement("FilmLength_", ref unk280);
else if (Type == ContentType.GameVariant)
if (!s.StreamElementOpt("EngineIconIndex", ref unk280, Predicates.IsNotNone))
EngineIconIndex = TypeExtensions.kNone;
s.StreamAttributeOpt("EngineCategoryIndex", ref EngineCategoryIndex, Predicates.IsNotNone);
if (Activity == 2)
s.StreamElement("HopperID", ref HopperId);
SerializeGameSpecificData(s);
}
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);
}
internal static void SerializeViaElementOpt <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s,
string elementName, ref ListLimitTraits traits)
where TDoc : class
where TCursor : class
{
bool streamed = s.StreamElementOpt(elementName, ref traits.MaxCount, Predicates.IsNotZero);
if (streamed && s.IsReading)
{
traits.InitializeBitLengths();
}
}
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 override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
base.Serialize(s);
var xs = s.GetSerializerInterface();
s.StreamAttributeOpt("Icon", ref mIconName, Predicates.IsNotNullOrEmpty);
s.StreamAttributeOpt("Test", ref mTest, Predicates.IsTrue);
s.StreamAttributeOpt("Alpha", ref mAlpha, Predicates.IsNotNone);
s.StreamAttributeOpt("Random", ref mIsRandom, Predicates.IsTrue);
s.StreamAttributeOpt("StatsID", ref mStatsID, Predicates.IsNotNone);
s.StreamAttributeOpt("LeaderPickerOrder", ref mLeaderPickerOrder, Predicates.IsNotNone);
s.StreamAttributeOpt("DefaultPlayerSlotFlags", ref mDefaultPlayerSlotFlags, Predicates.IsNotZero,
NumeralBase.Hex);
xs.StreamDBID(s, "Tech", ref mTechID, DatabaseObjectKind.Tech);
xs.StreamDBID(s, "Civ", ref mCivID, DatabaseObjectKind.Civ);
xs.StreamDBID(s, "Power", ref mPowerID, DatabaseObjectKind.Power);
s.StreamElementOpt("FlashCivID", ref mFlashCivID, Predicates.IsNotNone);
s.StreamStringOpt("FlashImg", ref mFlashImg, toLower: false, type: XML.XmlUtil.kSourceElement);
// TODO: HW360's FlashPortrait elements have an ending " character (sans a starting quote). Be careful!
s.StreamStringOpt("FlashPortrait", ref mFlashPortrait, toLower: false, type: XML.XmlUtil.kSourceElement);
XML.XmlUtil.Serialize(s, SupportPowers, BLeaderSupportPower.kBListXmlParams);
XML.XmlUtil.Serialize(s, StartingSquads, BLeaderStartingSquad.kBListXmlParams);
XML.XmlUtil.Serialize(s, StartingUnits, BLeaderStartingUnit.kBListXmlParams);
s.StreamBVector("RallyPointOffset", ref mRallyPointOffset);
s.StreamElementOpt("RepairRate", ref mRepairRate, Predicates.IsNotZero);
s.StreamElementOpt("RepairDelay", ref mRepairDelay, Predicates.IsNotZero);
XML.XmlUtil.Serialize(s, RepairCost, kRepairCostTypeValuesXmlParams);
s.StreamElementOpt("RepairTime", ref mRepairTime, Predicates.IsNotZero);
XML.XmlUtil.Serialize(s, ReverseHotDropCost, kReverseHotDropCostTypeValuesXmlParams);
XML.XmlUtil.Serialize(s, Populations, BPopulation.kBListXmlParams);
XML.XmlUtil.Serialize(s, Resources, BResource.kBListTypeValuesXmlParams);
s.StreamStringOpt("UIControlBackground", ref mUIControlBackground, toLower: false, type: XML.XmlUtil.kSourceElement);
}
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 void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
bool reading = s.IsReading;
#region Internal
if (reading)
{
int max_trigger_groups = 0, max_virtual_triggers = 0, max_script_values = 0
;
s.ReadElement(kMaxTriggerGroupsElementName, ref max_trigger_groups);
s.ReadElementOpt(kMaxVirtualTriggersElementName, ref max_virtual_triggers);
s.ReadElement(kMaxScriptValuesElementName, ref max_script_values);
#if false // #TODO_BLAM
TriggerGroupsDesc = Collections.ActiveListDesc <Editor.LogicalGroupUI> .
CreateForNullData(max_trigger_groups, fixedLength : false);
#endif
VirtualTriggersDesc = Collections.ActiveListDesc <Model.MegaloScriptVirtualTrigger> .
CreateForNullData(max_virtual_triggers, fixedLength : false);
VirtualTriggersDesc.ObjectToIndex = Model.MegaloScriptModelObject.kObjectToIndex;
ScriptValuesDesc = Collections.ActiveListDesc <Model.MegaloScriptValueBase> .
CreateForNullData(max_script_values, fixedLength : false);
ScriptValuesDesc.ObjectToIndex = Model.MegaloScriptModelObject.kObjectToIndex;
}
else
{
// s.WriteElement(kMaxTriggerGroupsElementName, TriggerGroupsDesc.Capacity);
s.WriteElement(kMaxVirtualTriggersElementName, VirtualTriggersDesc.Capacity);
s.WriteElement(kMaxScriptValuesElementName, ScriptValuesDesc.Capacity);
}
#endregion
#region Scripting
s.StreamElementEnum("EntryPoints", ref SupportedEntryPoints, true);
s.StreamElementOpt("SupportsVirtualTriggers", ref SupportsVirtualTriggers);
s.StreamElementOpt("StreamEntryPointIndexAsPointer", ref StreamEntryPointIndexAsPointer);
s.StreamElementOpt("StreamConditionsAndActionsRefsAsRefs", ref StreamConditionsAndActionsRefsAsRefs);
ListLimitTraits.SerializeViaElement(s, "MaxConditions", ref Conditions);
ListLimitTraits.SerializeViaElement(s, "MaxActions", ref Actions);
ListLimitTraits.SerializeViaElement(s, "MaxTriggers", ref Triggers);
if (reading)
{
UnionGroupsDesc = Collections.ActiveListDesc <Model.MegaloScriptUnionGroup> .
CreateForNullData(Conditions.MaxCount);
UnionGroupsDesc.ObjectToIndex = Model.MegaloScriptModelObject.kObjectToIndex;
ConditionsDesc = Collections.ActiveListDesc <Model.MegaloScriptCondition> .
CreateForNullData(Conditions.MaxCount);
ConditionsDesc.ObjectToIndex = Model.MegaloScriptModelObject.kObjectToIndex;
ActionsDesc = Collections.ActiveListDesc <Model.MegaloScriptAction> .
CreateForNullData(Actions.MaxCount);
ActionsDesc.ObjectToIndex = Model.MegaloScriptModelObject.kObjectToIndex;
TriggersDesc = Collections.ActiveListDesc <Model.MegaloScriptTrigger> .
CreateForNullData(Triggers.MaxCount);
TriggersDesc.ObjectToIndex = Model.MegaloScriptModelObject.kObjectToIndex;
}
#endregion
#region Static
ListLimitTraits.SerializeViaElement(s, "NumberOfGameEngineOptions", ref GameEngineOptions);
ListLimitTraits.SerializeViaElement(s, "MaxMultiplayerObjectTypes", ref MultiplayerObjectTypes);
ListLimitTraits.SerializeViaElement(s, "MaxMegaloStringIds", ref MegaloStringIds);
ListLimitTraits.SerializeViaElement(s, "MaxMegaloEngineSounds", ref MegaloEngineSounds);
ListLimitTraits.SerializeViaElement(s, "MaxGameIncidentTypes", ref GameIncidentTypes);
ListLimitTraits.SerializeViaElement(s, "MaxMegaloHudWidgetIcons", ref MegaloHudWidgetIcons);
ListLimitTraits.SerializeViaElement(s, "MaxGameEngineIcons", ref GameEngineIcons);
ListLimitTraits.SerializeViaElement(s, "MaxGameMedals", ref GameMedals);
ListLimitTraits.SerializeViaElementOpt(s, "MaxGameOrdnanceTypes", ref GameOrdnanceTypes);
ListLimitTraits.SerializeViaElement(s, "NumberOfEngineCategories", ref EngineCategories);
#endregion
#region Variant
ListLimitTraits.SerializeViaElement(s, "NumberOfLoadoutPalettes", ref LoadoutPalettes);
ListLimitTraits.SerializeViaElement(s, "MaxUserDefinedOptions", ref UserDefinedOptions);
ListLimitTraits.SerializeViaElement(s, "MaxUserDefinedOptionValues", ref UserDefinedOptionValues);
ListLimitTraits.SerializeViaElement(s, "MaxVariantStrings", ref VariantStrings);
ListLimitTraits.SerializeViaElementOpt(s, "MaxLoadouts", ref Loadouts);
ListLimitTraits.SerializeViaElement(s, "MaxPlayerTraits", ref PlayerTraits);
ListLimitTraits.SerializeViaElement(s, "MaxGameStatistics", ref GameStatistics);
ListLimitTraits.SerializeViaElement(s, "MaxHudWidgets", ref HudWidgets);
ListLimitTraits.SerializeViaElement(s, "MaxObjectFilters", ref ObjectFilters);
ListLimitTraits.SerializeViaElementOpt(s, "MaxGameObjectFilters", ref GameObjectFilters);
#endregion
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
var xs = s.GetSerializerInterface();
var td = KSoft.Debug.TypeCheck.CastReference <BTacticData>(s.UserData);
s.StreamElementEnumOpt("ActionType", ref mActionType, kNotInvalidActionType);
s.StreamElementOpt("ProjectileSpread", ref mProjectileSpread, PhxPredicates.IsNotInvalid);
xs.StreamDBID(s, "SquadType", ref mSquadTypeID, DatabaseObjectKind.Squad);
td.StreamID(s, "Weapon", ref mWeaponID, TacticDataObjectKind.Weapon);
td.StreamID(s, "LinkedAction", ref mLinkedActionID, TacticDataObjectKind.Action);
s.StreamElementEnumOpt("SquadMode", ref mSquadMode, kNotInvalidSquadMode);
s.StreamElementEnumOpt("NewSquadMode", ref mNewSquadMode, kNotInvalidSquadMode);
#if false
td.StreamID(s, "NewTacticState", ref mNewTacticStateID, BTacticData.ObjectKind.TacticState);
#endif
#region Work
s.StreamElementOpt("WorkRate", ref mWorkRate, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("WorkRateVariance", ref mWorkRateVariance, PhxPredicates.IsNotInvalid);
s.StreamElementOpt("WorkRange", ref mWorkRange, PhxPredicates.IsNotInvalid);
#endregion
#region DamageModifiers
using (var bm = s.EnterCursorBookmarkOpt("DamageModifiers", this, o => mDamageModifiersDmg != PhxUtil.kInvalidSingle)) if (bm.IsNotNull)
{
s.StreamAttribute("damage", ref mDamageModifiersDmg);
s.StreamAttributeOpt("damageTaken", ref mDamageModifiersDmgTaken, PhxPredicates.IsNotInvalid);
s.StreamAttributeOpt("byCombatValue", ref mDamageModifiersByCombatValue, Predicates.IsTrue);
}
#endregion
xs.StreamTypeName(s, "Resource", ref mResourceID, GameDataObjectKind.Cost);
// if element equals 'true' this is the default action
s.StreamElementOpt("Default", ref mDefault, Predicates.IsTrue);
td.StreamID(s, "SlaveAttackAction", ref mSlaveAttackActionID, TacticDataObjectKind.Action);
td.StreamID(s, "BaseDPSWeapon", ref mBaseDPSWeaponID, TacticDataObjectKind.Weapon);
s.StreamElementEnumOpt("PersistentActionType", ref mPersistentActionType, kNotInvalidActionType);
#region Duration
using (var bm = s.EnterCursorBookmarkOpt("Duration", this, o => mDuration != PhxUtil.kInvalidSingle)) if (bm.IsNotNull)
{
s.StreamCursor(ref mDuration);
s.StreamAttributeOpt("DurationSpread", ref mDurationSpread, PhxPredicates.IsNotInvalid);
}
#endregion
#region AutoRepair
using (var bm = s.EnterCursorBookmarkOpt("AutoRepair", this, o => mAutoRepairIdleTime != PhxUtil.kInvalidSingle)) if (bm.IsNotNull)
{
s.StreamAttribute("AutoRepairIdleTime", ref mAutoRepairIdleTime);
s.StreamAttribute("AutoRepairThreshold", ref mAutoRepairThreshold);
s.StreamAttribute("AutoRepairSearchDistance", ref mAutoRepairSearchDistance);
}
#endregion
xs.StreamDBID(s, "InvalidTarget", ref mInvalidTargetObjectID, DatabaseObjectKind.Object);
#region ProtoObject
using (var bm = s.EnterCursorBookmarkOpt("ProtoObject", this, o => mProtoObjectID.IsNotNone())) if (bm.IsNotNull)
{
// TODO: This IS optional, right? Only on 'true'?
// inner text: if 0, proto object, if not, proto squad
s.StreamAttributeOpt("Squad", ref mProtoObjectIsSquad, Predicates.IsTrue);
xs.StreamDBID(s, null, ref mSquadTypeID,
mProtoObjectIsSquad ? DatabaseObjectKind.Squad : DatabaseObjectKind.Object, false, XML.XmlUtil.kSourceCursor);
}
#endregion
#if false
xs.StreamXmlForStringID(s, "Count", ref mCountStringID);
#endif
s.StreamElementOpt("MaxNumUnitsPerformAction", ref mMaxNumUnitsPerformAction, Predicates.IsNotNone);
s.StreamElementOpt("DamageCharge", ref mDamageCharge, PhxPredicates.IsNotInvalid);
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
s.StreamAttribute("EditorColor", ref mEditorColor, NumeralBase.Hex);
s.StreamElementOpt("ImpactEffect", ref mImpactEffect, Predicates.IsNotNullOrEmpty);
}
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 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
{
bool reading = s.IsReading;
#region Value0
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value0) || reading) &&
s.StreamElementOpt("Value0", ref mValue0))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value0);
}
#endregion
#region Value1
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value1) || reading) &&
s.StreamElementOpt("Value1", ref mValue1))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value1);
}
#endregion
#region Value2
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value2) || reading) &&
s.StreamElementOpt("Value2", ref mValue2))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value2);
}
#endregion
#region Value3
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value3) || reading) &&
s.StreamElementOpt("Value3", ref mValue3))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value3);
}
#endregion
#region Value4
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value4) || reading) &&
s.StreamElementOpt("Value4", ref mValue4))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value4);
}
#endregion
#region Value5
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value5) || reading) &&
s.StreamElementOpt("Value5", ref mValue5))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value5);
}
#endregion
#region Value6
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value6) || reading) &&
s.StreamElementOpt("Value6", ref mValue6))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value6);
}
#endregion
#region Value7
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value7) || reading) &&
s.StreamElementOpt("Value7", ref mValue7))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value7);
}
#endregion
#region Value8
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value8) || reading) &&
s.StreamElementOpt("Value8", ref mValue8))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value8);
}
#endregion
#region Value9
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value9) || reading) &&
s.StreamElementOpt("Value9", ref mValue9))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value9);
}
#endregion
#region Value10
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value10) || reading) &&
s.StreamElementOpt("Value10", ref mValue10))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value10);
}
#endregion
#region Value11
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value11) || reading) &&
s.StreamElementOpt("Value11", ref mValue11))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value11);
}
#endregion
#region Value12
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value12) || reading) &&
s.StreamElementOpt("Value12", ref mValue12))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value12);
}
#endregion
#region Value13
if ((EnumFlags.Test(Modifiers, WeaponTuningModifiers.Value13) || reading) &&
s.StreamElementOpt("Value13", ref mValue13))
{
EnumFlags.Add(ref Modifiers, WeaponTuningModifiers.Value13);
}
#endregion
}
public override void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
{
s.StreamElementOpt("DeathAnimation", ref mDeathAnimation, Predicates.IsNotNullOrEmpty);
XML.XmlUtil.Serialize(s, Modifiers, BWeaponModifier.kBListXmlParams);
}
