public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
base.StreamXml(s, mode, xs);
xs.StreamXmlForDBID(s, mode, kXmlElementTech, ref mTechID, DatabaseObjectKind.Tech);
s.StreamElementOpt(mode, kXmlElementPowerFromHero, ref mPowerFromHero, Util.kNotFalsePredicate);
}
public void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
if (mode == FA.Write)
{
var task_sort_cond = Task.Factory.StartNew(() => Conditions.Sort(SortById));
var task_sort_effe = Task.Factory.StartNew(() => Effects.Sort(SortById));
var task_unknowns = Task <int> .Factory.StartNew(() =>
{
using (s.EnterCursorBookmark("Unknowns"))
return(WriteUnknowns(s, mode, xs));
});
s.WriteAttribute("UnknownCount", task_unknowns.Result);
s.WriteAttribute("ConditionsCount", Conditions.Count);
s.WriteAttribute("EffectsCount", Effects.Count);
Task.WaitAll(task_sort_cond, task_sort_effe);
}
XML.Util.Serialize(s, mode, xs, Conditions, BTriggerProtoCondition.kBListXmlParams);
XML.Util.Serialize(s, mode, xs, Effects, BTriggerProtoEffect.kBListXmlParams);
if (mode == FA.Read)
{
foreach (var c in Conditions)
{
LookupTableAdd(c);
}
foreach (var e in Effects)
{
LookupTableAdd(e);
}
}
}
void StreamCommandData(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
const string attr_name = kXmlAttrODT_Command_Data;
switch (CommandType)
{
case BProtoObjectCommandType.Research: // proto tech
xs.StreamXmlForDBID(s, mode, attr_name, ref CommandData, DatabaseObjectKind.Tech, false, XML.Util.kSourceAttr);
break;
case BProtoObjectCommandType.TrainUnit: // proto object
case BProtoObjectCommandType.Build:
case BProtoObjectCommandType.BuildOther:
xs.StreamXmlForDBID(s, mode, attr_name, ref CommandData, DatabaseObjectKind.Object, false, XML.Util.kSourceAttr);
break;
case BProtoObjectCommandType.TrainSquad: // proto squad
xs.StreamXmlForDBID(s, mode, attr_name, ref CommandData, DatabaseObjectKind.Squad, false, XML.Util.kSourceAttr);
break;
case BProtoObjectCommandType.ChangeMode: // unused
s.StreamAttributeEnum(mode, attr_name, ref CommandDataSM);
break;
case BProtoObjectCommandType.Ability:
xs.StreamXmlForDBID(s, mode, attr_name, ref CommandData, DatabaseObjectKind.Ability, false, XML.Util.kSourceAttr);
break;
case BProtoObjectCommandType.Power:
xs.StreamXmlForDBID(s, mode, attr_name, ref CommandData, DatabaseObjectKind.Power, false, XML.Util.kSourceAttr);
break;
}
}
public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
base.StreamXml(s, mode, xs);
s.StreamAttributeOpt(mode, kXmlAttrId, ref mId, Util.kNotInvalidPredicate);
s.StreamElementEnumOpt(mode, kXmlElementObjectClass, ref mClassType, x => x != BProtoObjectClassType.Invalid);
XML.Util.Serialize(s, mode, xs, Veterancy, BProtoObjectVeterancy.kBListExplicitIndexXmlParams);
s.StreamElementOpt(mode, kXmlElementCostEscalation, ref mCostEscalation, Util.kNotInvalidPredicateSingle);
s.StreamElementOpt(mode, kXmlElementHitpoints, ref mHitpoints, Util.kNotInvalidPredicateSingle);
s.StreamElementOpt(mode, kXmlElementAttackGradeDPS, ref mAttackGradeDPS, Util.kNotInvalidPredicateSingle);
// s.StreamElementOpt(mode, kXmlElementCombatValue, ref mCombatValue, Util.kNotInvalidPredicateSingle);
s.StreamElementOpt(mode, kXmlElementBounty, ref mBounty, Util.kNotInvalidPredicateSingle);
XML.Util.Serialize(s, mode, xs, Populations, BPopulation.kBListXmlParamsSingle);
XML.Util.Serialize(s, mode, xs, PopulationsCapAddition, BPopulation.kBListXmlParamsSingle_CapAddition);
(xs as XML.BDatabaseXmlSerializerBase).StreamXmlTactic(s, mode, kXmlElementTactics, this, ref mHasTactics);
XML.Util.Serialize(s, mode, xs, Rates, BGameData.kRatesBListTypeValuesXmlParams);
XML.Util.Serialize(s, mode, xs, AddResource, BResource.kBListTypeValuesXmlParams_AddResource, kXmlElementAddRsrcAttrAmount);
XML.Util.Serialize(s, mode, xs, Flags, XML.BBitSetXmlParams.kFlagsSansRoot);
XML.Util.Serialize(s, mode, xs, ObjectTypes, kObjectTypesXmlParams);
}
void StreamConditions(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
var k_AND_params = BTriggerCondition.kBListXmlParams_And;
if (mode == FA.Read)
{
if (OrConditions = !s.ElementsExists(k_AND_params.RootName))
{
XML.Util.Serialize(s, mode, xs, Conditions, BTriggerCondition.kBListXmlParams_Or);
}
else
{
XML.Util.Serialize(s, mode, xs, Conditions, k_AND_params);
}
}
else if (mode == FA.Write)
{
// Even if there are no conditions, the runtime expects there to be an empty And tag :|
// Well, technically we could use an empty Or tag as well, but it wouldn't be consistent
// with the engine. The runtime will assume the the TS is bad if neither tag is present
if (Conditions.Count == 0)
{
s.WriteElement(k_AND_params.RootName);
}
else
{
XML.Util.Serialize(s, mode, xs, Conditions,
OrConditions ? BTriggerCondition.kBListXmlParams_Or : k_AND_params);
}
}
}
public void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
s.StreamAttribute(mode, DatabaseNamedObject.kXmlAttrNameN, ref mName);
s.StreamAttributeEnum(mode, kXmlAttrType, ref mType);
s.StreamAttribute(mode, kXmlAttrNextTriggerVar, ref mNextTriggerVarID);
s.StreamAttribute(mode, kXmlAttrNextTrigger, ref mNextTriggerID);
s.StreamAttribute(mode, kXmlAttrNextCondition, ref mNextConditionID);
s.StreamAttribute(mode, kXmlAttrNextEffect, ref mNextEffectID);
s.StreamAttribute(mode, kXmlAttrExternal, ref mExternal);
using (s.EnterOwnerBookmark(this))
{
XML.Util.Serialize(s, mode, xs, Groups, BTriggerGroup.kBListXmlParams);
if (mode == FA.Read)
{
BuildDictionary(out m_dbiGroups, Groups);
}
XML.Util.Serialize(s, mode, xs, Vars, BTriggerVar.kBListXmlParams);
if (mode == FA.Read)
{
BuildDictionary(out m_dbiVars, Vars);
}
XML.Util.Serialize(s, mode, xs, Triggers, BTrigger.kBListXmlParams);
if (mode == FA.Read)
{
BuildDictionary(out m_dbiTriggers, Triggers);
}
}
(xs as XML.BTriggerScriptSerializer).TriggerDb.UpdateFromGameData(this);
}
public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
s.StreamAttribute(mode, kXmlAttrObjectDBID, ref mObjectDBID);
XML.Util.Serialize(s, mode, xs, Effects, BCollectibleSkullEffect.kBListXmlParams);
xs.StreamXmlForStringID(s, mode, kXmlElementDescriptionID, ref mDescriptionID);
XML.Util.StreamElementNamedFlag(s, mode, kXmlElementHidden, ref mHidden);
}
public void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
xs.StreamXmlForDBID(s, mode, kXmlAttrBase, ref mBaseObjectID, DatabaseObjectKind.Object, false, XML.Util.kSourceAttr);
xs.StreamXmlForDBID(s, mode, kXmlAttrInfected, ref mInfectedObjectID, DatabaseObjectKind.Object, false, XML.Util.kSourceAttr);
if(xs.Database.Engine.Build != PhxEngineBuild.Alpha)
xs.StreamXmlForDBID(s, mode, kXmlAttrInfectedSquad, ref mInfectedSquadID, DatabaseObjectKind.Squad, false, XML.Util.kSourceAttr);
}
public void StreamCommand(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
if (s.StreamAttributeEnumOpt(mode, kXmlAttrODT_Command_Type, ref CommandType, e => e != BProtoObjectCommandType.Invalid))
{
StreamCommandData(s, mode, xs);
}
}
public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
s.StreamAttribute(mode, kXmlAttrDbId, ref mDbId);
s.StreamAttribute(mode, kXmlAttrVersion, ref mVersion);
XML.Util.Serialize(s, mode, xs, Params, BTriggerParam.kBListExplicitIndexXmlParams);
}
//string mValue;
public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
base.StreamXml(s, mode, xs);
s.StreamAttributeEnum(mode, kXmlAttrType, ref mType);
s.StreamAttribute(mode, kXmlAttrIsNull, ref mIsNull);
//s.StreamCursor(mode, ref mValue);
}
static void SetupStream(IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
s.IgnoreCaseOnEnums = true;
s.ExceptionOnEnumParseFail = true;
s.StreamMode = mode;
s.InitializeAtRootElement();
s.SetSerializerInterface(xs);
}
public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
base.StreamXml(s, mode, xs);
s.StreamAttribute(mode, kXmlAttrInvert, ref mInvert);
s.StreamAttribute(mode, kXmlAttrAsync, ref mAsync);
s.StreamAttribute(mode, kXmlAttrAsyncParameterKey, ref mAsyncParameterKey);
}
public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
base.StreamXml(s, mode, xs);
XML.Util.Serialize(s, mode, xs, ResourceCost, mResourceCostXmlParams);
s.StreamElementOpt(mode, kXmlElementBuildPoints, ref mBuildTime, Util.kNotInvalidPredicateSingle);
s.StreamElementOpt(mode, kXmlElementResearchPoints, ref mResearchTime, Util.kNotInvalidPredicateSingle);
}
void StreamXmlStartingUnit(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
using (s.EnterCursorBookmark(mode, kXmlElementStartingUnit))
{
xs.StreamXmlForDBID(s, mode, null, ref mStartingUnitID, DatabaseObjectKind.Object, false, XML.Util.kSourceCursor);
xs.StreamXmlForDBID(s, mode, kXmlElementStartingUnitAttrBuildOther, ref mStartingUnitBuildOtherID, DatabaseObjectKind.Object, false, XML.Util.kSourceAttr);
}
}
public void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
//if (mode == FA.Read) s.ReadCursorName(ref mType);
s.StreamAttributeEnum(mode, kXmlAttrType, ref mType);
s.StreamAttribute(mode, kXmlAttrSigId, ref mSigID);
s.StreamAttribute(mode, DatabaseNamedObject.kXmlAttrNameN, ref mName);
s.StreamAttributeOpt(mode, kXmlAttrOptional, ref mOptional, Util.kNotFalsePredicate);
s.StreamCursorEnum(mode, ref mVarType);
}
public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
base.StreamXml(s, mode, xs);
if (s.StreamAttributeOpt(mode, kXmlAttrAsync, ref mAsync, Util.kNotFalsePredicate))
{
s.StreamAttribute(mode, kXmlAttrAsyncParameterKey, ref mAsyncParameterKey);
}
}
void StreamXmlValueID(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
DatabaseObjectKind kind = ObjectKind;
if (kind != DatabaseObjectKind.None)
{
xs.StreamXmlForDBID(s, mode, null, ref mValueID, kind, false, XML.Util.kSourceCursor);
}
}
public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
base.StreamXml(s, mode, xs);
s.StreamAttribute(mode, kXmlAttrDbId, ref mDbId);
s.StreamAttribute(mode, kXmlAttrVersion, ref mVersion);
// Stream it last, so when we save it ourselves, the (relatively) fixed width stuff comes first
// XML.Util.StreamInternString(s, mode, kXmlAttrType, ref mTypeStr, false);
}
void StreamXmlTargets(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
if (mode == FA.Read)
{
Targets = new Collections.BListArray <BProtoTechEffectTarget>();
}
XML.Util.Serialize(s, mode, xs, Targets, BProtoTechEffectTarget.kBListXmlParams);
}
public void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
s.StreamAttributeOpt(mode, kXmlAttrXP, ref mXP, Util.kNotZeroPredicateSingle);
s.StreamAttributeOpt(mode, kXmlAttrDamage, ref mDamage, Util.kNotZeroPredicateSingle);
s.StreamAttributeOpt(mode, kXmlAttrVelocity, ref mVelocity, Util.kNotZeroPredicateSingle);
s.StreamAttributeOpt(mode, kXmlAttrAccuracy, ref mAccuracy, Util.kNotZeroPredicateSingle);
s.StreamAttributeOpt(mode, kXmlAttrWorkRate, ref mWorkRate, Util.kNotZeroPredicateSingle);
s.StreamAttributeOpt(mode, kXmlAttrWeaponRange, ref mWeaponRange, Util.kNotZeroPredicateSingle);
s.StreamAttributeOpt(mode, kXmlAttrDamageTaken, ref mDamageTaken, Util.kNotZeroPredicateSingle);
}
public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
base.StreamXml(s, mode, xs);
s.StreamElementEnumOpt(mode, kXmlElementType, ref mType, e => e != BAbilityType.Invalid);
s.StreamElementEnumOpt(mode, kXmlElementSquadMode, ref mSquadMode, e => e != BSquadMode.Invalid);
s.StreamElementOpt(mode, kXmlElementDamageTakenModifier, ref mDamageTakenModifier, Util.kNotInvalidPredicateSingle);
s.StreamElementEnumOpt(mode, kXmlElementTargetType, ref mTargetType, e => e != BAbilityTargetType.Invalid);
s.StreamElementOpt(mode, kXmlElementDuration, ref mDuration, Util.kNotInvalidPredicateSingle);
}
public void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
using (s.EnterOwnerBookmark(this))
{
XML.Util.Serialize(s, mode, xs, Weapons, BWeapon.kBListXmlParams);
//XML.Util.Serialize(s, mode, db, TacticStates, BTacticState.kBListXmlParams);
XML.Util.Serialize(s, mode, xs, Actions, BProtoAction.kBListXmlParams);
Tactic.StreamXml(s, mode, xs);
}
}
public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
base.StreamXml(s, mode, xs);
if (ShouldStreamUnits(s, mode))
{
XML.Util.Serialize(s, mode, xs, Units, BProtoSquadUnit.kBListXmlParams);
}
XML.Util.Serialize(s, mode, xs, Flags, XML.BBitSetXmlParams.kFlagsSansRoot);
}
public void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
if (mode == FA.Read)
{
s.ReadCursorName(ref mType);
}
s.StreamAttribute(mode, kXmlAttrSigId, ref mSigID);
s.StreamAttribute(mode, DatabaseNamedObject.kXmlAttrNameN, ref mName);
s.StreamAttribute(mode, kXmlAttrOptional, ref mOptional);
s.StreamCursor(mode, ref mVarID);
}
public void StreamTrainLimit(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs, DatabaseObjectKind kind)
{
if (kind == DatabaseObjectKind.Object)
{
xs.StreamXmlForDBID(s, mode, kXmlAttrODT_TrainLimit_Unit, ref TrainLimitType, DatabaseObjectKind.Object, false, XML.Util.kSourceAttr);
}
else if (kind == DatabaseObjectKind.Squad)
{
xs.StreamXmlForDBID(s, mode, kXmlAttrODT_TrainLimit_Squad, ref TrainLimitType, DatabaseObjectKind.Squad, false, XML.Util.kSourceAttr);
}
}
public void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
xs.StreamXmlForDBID(s, mode, kXmlAttrUnit, ref mUnitID, DatabaseObjectKind.Object, false, XML.Util.kSourceAttr);
if (!s.StreamAttributeEnumOpt(mode, kXmlAttrOperator, ref mOperator, e => e != BProtoTechTypeCountOperator.None))
{
mOperator = BProtoTechTypeCountOperator.None;
}
if (!s.StreamAttributeOpt(mode, kXmlAttrCount, ref mCount, Util.kNotInvalidPredicateInt16))
{
mCount = Util.kInvalidInt32;
}
}
public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
base.StreamXml(s, mode, xs);
s.StreamElementEnum(mode, kXmlElementStatus, ref mStatus);
if (ShouldStreamPrereqs(s, mode))
{
Prereqs.StreamXml(s, mode, xs);
}
XML.Util.Serialize(s, mode, xs, Effects, BProtoTechEffect.kBListXmlParams);
}
int WriteUnknowns(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
int count = 0;
for (int x = 1; x < mUsedIds.Length; x++)
{
if (!mUsedIds[x])
{
s.WriteElement("Unknown", x);
count++;
}
}
return(count);
}
public override void StreamXml(KSoft.IO.XmlElementStream s, FA mode, XML.BXmlSerializerInterface xs)
{
base.StreamXml(s, mode, xs);
xs.StreamXmlForDBID(s, mode, kXmlElementTech, ref mTechID, DatabaseObjectKind.Tech);
xs.StreamXmlForDBID(s, mode, kXmlElementCiv, ref mCivID, DatabaseObjectKind.Civ);
xs.StreamXmlForDBID(s, mode, kXmlElementPower, ref mPowerID, DatabaseObjectKind.Power);
xs.StreamXmlForStringID(s, mode, kXmlElementNameID, ref mNameID);
XML.Util.Serialize(s, mode, xs, Resources, BResource.kBListTypeValuesXmlParams);
if (ShouldStreamStartingUnit(s, mode))
{
StreamXmlStartingUnit(s, mode, xs);
}
XML.Util.Serialize(s, mode, xs, StartingSquads, kStartingSquadBListXmlParams);
XML.Util.Serialize(s, mode, xs, Populations, BPopulation.kBListXmlParams);
}
