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>(MegaloScriptModel model, IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
if ((model.TagElementStreamSerializeFlags & MegaloScriptModelTagElementStreamFlags.EmbedObjects) != 0)
{
s.StreamElements("E", mElements, model, MegaloScriptModelObjectHandle.SerializeForEmbed);
}
else
{
s.StreamElements("E", mElements, model, MegaloScriptModelObjectHandle.Serialize);
}
if (s.IsReading)
{
// auto-create union groups if needed
if (model.TagElementStreamSerializeFlags.EmbedObjectsWriteSansIds())
{
MegaloScriptUnionGroup.PostprocessConditionsForEmbedObjectsWriteSansIds(model, s, mElements);
}
else
{
MegaloScriptUnionGroup.ReadPostprocessConditions(model, s, mElements);
}
}
}
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 td = KSoft.Debug.TypeCheck.CastReference <BTacticData>(s.UserData);
XML.XmlUtil.Serialize(s, TargetRules, BTacticTargetRule.kBListXmlParams);
s.StreamElements("PersistentAction", PersistentActions, td, BTacticData.StreamProtoActionID);
s.StreamElements("PersistentSquadAction", PersistentSquadActions, td, BTacticData.StreamProtoActionID);
}
static void SerializeLanguages <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (s.EnterCursorBookmark("Languages"))
s.StreamElements("Language", gLanguageNames);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamAttributeEnum("exceptionType", ref ExceptionType);
s.StreamElements("MapID", MapIds);
}
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();
xs.StreamDBID(s, XML.XmlUtil.kNoXmlName, ref mToMergeSquadID, DatabaseObjectKind.Squad, false, XML.XmlUtil.kSourceCursor);
s.StreamElements("MergedSquad", BaseSquadIDs, xs, XML.BDatabaseXmlSerializerBase.StreamSquadID);
}
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 => PkgName, Predicates.IsNotNullOrEmpty);
s.StreamAttributeOpt("alignment", this, obj => Alignment, Predicates.IsNotZero);
using (var bm = s.EnterCursorBookmarkOpt("Files", FileNames, Predicates.HasItems))
s.StreamElements("File", FileNames);
}
}
static void SerializePrototypes <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
// #REVIEW_BLAM: we don't current validate the series name
string series = kSeriesName;
s.StreamAttribute("series", ref series);
using (var bm = s.EnterCursorBookmarkOpt("Engines", gEngines, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamElements("Engine", gEngines, (object)null,
BlamEngine.SerializePrototype);
}
}
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 void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
s.StreamAttribute("name", ref Name);
s.StreamElements("Member", Members);
if (s.IsReading)
{
int index = 0;
foreach (string name in Members)
{
NameToIndex.Add(name, index++);
}
}
Contract.Assert(!IsCodeEnum);
}
public ICollection <BlobObject> StreamObjects <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s,
ICollection <BlobObject> results, Engine.BlamEngineTargetHandle gameTarget)
where TDoc : class
where TCursor : class
{
Contract.Requires <ArgumentNullException>(!gameTarget.IsNone);
if (s.IsReading)
{
results = new List <BlobObject>();
}
var ctxt = new SerializeObjectContext(this, gameTarget);
s.StreamElements("BlobObject", results, ctxt, SerializeObject,
_ctxt => null);
return(results);
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (s.EnterCursorBookmark("SerializeFlags"))
s.StreamCursorEnum(ref TagElementStreamSerializeFlags, true);
#region TryToPort sanity checks
if ((TagElementStreamSerializeFlags & MegaloScriptModelTagElementStreamFlags.TryToPort) != 0)
{
if (s.IsWriting)
{
if (Proto.MegaloScriptDatabase.HaloReach == null || Proto.MegaloScriptDatabase.Halo4 == null)
{
throw new InvalidOperationException("Can't port, other game's DB isn't loaded");
}
}
else if (s.IsReading)
{
var ex = new InvalidOperationException("Can't load variants saved with TryToPort");
s.ThrowReadException(ex);
}
}
#endregion
bool embed_model_objects = TagElementStreamSerializeFlags.EmbedObjects();
bool write_sans_ids = TagElementStreamSerializeFlags.EmbedObjectsWriteSansIds();
#region Version sanity checks
if ((TagElementStreamSerializeFlags & MegaloScriptModelTagElementStreamFlags.IgnoreVersionIds) == 0)
{
s.StreamVersionViaAttribute("version", kVersion, "MegaFloW Script");
s.StreamVersionViaAttribute("dbVersion", Database.Version, "Database");
}
#endregion
using (s.EnterOwnerBookmark(this))
{
#region helpful info dump
if (s.IsWriting && embed_model_objects && !write_sans_ids)
{
using (s.EnterCursorBookmark("IDs"))
{
s.WriteAttribute("NextCondID", Conditions.FirstInactiveIndex);
s.WriteAttribute("NextActionID", Actions.FirstInactiveIndex);
s.WriteAttribute("NextValueID", Values.FirstInactiveIndex);
s.WriteAttribute("NextTrigID", Triggers.FirstInactiveIndex);
if (Database.Limits.SupportsVirtualTriggers)
{
s.WriteAttribute("NextVirtualTriggerID", VirtualTriggers.FirstInactiveIndex);
}
}
}
#endregion
#region ObjectTypeReferences
using (var bm = s.EnterCursorBookmarkOpt("ObjectTypeReferences", ObjectTypeReferences, Predicates.HasBits)) if (bm.IsNotNull)
{
ObjectTypeReferences.Serialize(s, "Ref", this, SerializeObjectTypeReference,
Database.StaticDatabase.ObjectTypeList.Types.Count - 1);
}
#endregion
#region GameStatistics
using (var bm = s.EnterCursorBookmarkOpt("Statistics", GameStatistics, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamableElements("Stat", GameStatistics, this, _this => _this.NewGameStatistic());
}
#endregion
#region HudWidgets
using (var bm = s.EnterCursorBookmarkOpt("HudWidgets", HudWidgets, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamableElements("Widget", HudWidgets);
}
#endregion
#region Object Filters
using (var bm = s.EnterCursorBookmarkOpt("ObjectFilters", ObjectFilters, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamableElements("Filter", ObjectFilters);
}
if (Database.Limits.SupportsGameObjectFilters)
{
SerializeGameObjectFilters(s);
}
#endregion
#region Variables
Predicate <MegaloScriptModelVariableSet> set_is_not_empty = v => v.IsNotEmpty;
using (var bm = s.EnterCursorBookmarkOpt("GlobalVariables", GlobalVariables, set_is_not_empty)) if (bm.IsNotNull)
{
GlobalVariables.Serialize(this, s);
}
using (var bm = s.EnterCursorBookmarkOpt("PlayerVariables", PlayerVariables, set_is_not_empty)) if (bm.IsNotNull)
{
PlayerVariables.Serialize(this, s);
}
using (var bm = s.EnterCursorBookmarkOpt("ObjectVariables", ObjectVariables, set_is_not_empty)) if (bm.IsNotNull)
{
ObjectVariables.Serialize(this, s);
}
using (var bm = s.EnterCursorBookmarkOpt("TeamVariables", TeamVariables, set_is_not_empty)) if (bm.IsNotNull)
{
TeamVariables.Serialize(this, s);
}
#endregion
#region UnionGroups
if (!TagElementStreamSerializeFlags.EmbedObjectsWriteSansIds())
{
using (s.EnterCursorBookmark("UnionGroups")) Collections.ActiveListUtil.
Serialize(s, "Group", UnionGroups, this, NewUnionGroupFromTagStream);
}
#endregion
#region Values or Global Values
// #NOTE_BLAM: A Values element will be created even if there are no global values
using (s.EnterCursorBookmark("Values")) Collections.ActiveListUtil.
Serialize(s, "Value", Values, this, MegaloScriptValueBase.NewFromTagStream,
embed_model_objects ? MegaloScriptValueBase.SkipIfNotGlobalPredicate : null);
#endregion
#region Conditions / Actions / Virtual Triggers (non-embedded)
if (!embed_model_objects)
{
using (s.EnterCursorBookmark("Conditions")) Collections.ActiveListUtil.
Serialize(s, "Condition", Conditions, this, NewConditionFromTagStream);
using (s.EnterCursorBookmark("Actions")) Collections.ActiveListUtil.
Serialize(s, "Action", Actions, this, NewActionFromTagStream);
using (s.EnterCursorBookmark("VirtualTriggers")) Collections.ActiveListUtil.
Serialize(s, "Trigger", VirtualTriggers, this, NewVirtualTriggerFromTagStream);
}
#endregion
using (s.EnterCursorBookmark("Triggers")) Collections.ActiveListUtil.
Serialize(s, "Trigger", Triggers, this, NewTriggerFromTagStream,
embed_model_objects ? MegaloScriptTrigger.SkipIfNotRootPredicate : null,
GetTriggersTagElementStreamReadMode);
#region Trigger Indexes
using (s.EnterCursorBookmark("EntryPoints"))
{
var id_resolving_ctxt = new TriggerIndexNameResolvingContext(this);
var id_resolver = TriggerIndexNameResolvingContext.IdResolver;
var name_resolver = TriggerIndexNameResolvingContext.NameResolver;
s.StreamElementOptIdAsString("Initialization", ref mInitializationTriggerIndex, id_resolving_ctxt, id_resolver, name_resolver, Predicates.IsNotNull);
s.StreamElementOptIdAsString("LocalInitialization", ref mLocalInitializationTriggerIndex, id_resolving_ctxt, id_resolver, name_resolver, Predicates.IsNotNull);
s.StreamElementOptIdAsString("HostMigration", ref mHostMigrationTriggerIndex, id_resolving_ctxt, id_resolver, name_resolver, Predicates.IsNotNull);
s.StreamElementOptIdAsString("DoubleHostMigration", ref mDoubleHostMigrationTriggerIndex, id_resolving_ctxt, id_resolver, name_resolver, Predicates.IsNotNull);
s.StreamElementOptIdAsString("ObjectDeathEvent", ref mObjectDeathEventTriggerIndex, id_resolving_ctxt, id_resolver, name_resolver, Predicates.IsNotNull);
s.StreamElementOptIdAsString("Local", ref mLocalTriggerIndex, id_resolving_ctxt, id_resolver, name_resolver, Predicates.IsNotNull);
s.StreamElementOptIdAsString("Pregame", ref mPregameTriggerIndex, id_resolving_ctxt, id_resolver, name_resolver, Predicates.IsNotNull);
s.StreamElementOptIdAsString("Incident", ref mIncidentTriggerIndex, id_resolving_ctxt, id_resolver, name_resolver, Predicates.IsNotNull);
}
#endregion
using (var bm = s.EnterCursorBookmarkOpt("ExecutionOrder", TriggerExecutionOrder, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamElements("Trigger", TriggerExecutionOrder, this, SerializeTriggerExecutionOrder);
}
}
#region List count sanity checks
if (s.IsReading)
{
// #TODO_IMPLEMENT: sanity check list counts
var limits = Database.Limits;
limits.GameStatistics.ValidateListCount(GameStatistics, "GameStatistics", s);
GlobalVariables.ValidateVariableListCounts(s);
PlayerVariables.ValidateVariableListCounts(s);
ObjectVariables.ValidateVariableListCounts(s);
TeamVariables.ValidateVariableListCounts(s);
limits.HudWidgets.ValidateListCount(HudWidgets, "HudWidgets", s);
limits.ObjectFilters.ValidateListCount(ObjectFilters, "ObjectFilters", s);
limits.GameObjectFilters.ValidateListCount(CandySpawnerFilters, "GameObjectFilters", s);
}
#endregion
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
using (s.EnterOwnerBookmark(this))
{
s.StreamAttribute("version", ref Version);
using (s.EnterCursorBookmark("Limits"))
Limits.Serialize(s);
using (var bm = s.EnterCursorBookmarkOpt("SingleEncodings", SingleEncodings, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamableElements("Traits", SingleEncodings);
}
using (s.EnterCursorBookmark("EnumTypes"))
s.StreamableElements("Type", Enums, e => !e.IsCodeEnum);
if (s.IsReading)
{
SingleEncodings.Sort((x, y) => string.CompareOrdinal(x.Name, y.Name));
Enums.Sort((x, y) => string.CompareOrdinal(x.Name, y.Name));
}
using (s.EnterCursorBookmark("VariableSets"))
s.StreamableElements("Set", VariableSets,
"type", MegaloScriptProtoVariableSet.StreamSetType);
using (s.EnterCursorBookmark("ValueTypes"))
s.StreamElements("Type", ValueTypes, this, SerializeValueType);
if (s.IsReading)
{
ValueTypes.ForEach(type => NameToValueType.Add(ValueTypeNames[type.NameIndex], type));
}
using (s.EnterCursorBookmark("VariableReferenceTypes"))
s.StreamableElements("Type", VariableRefTypes,
"type", MegaloScriptProtoVariableReference.StreamType);
using (s.EnterCursorBookmark("Conditions"))
s.StreamableElements("Condition", Conditions);
using (s.EnterCursorBookmark("ActionTemplates"))
s.StreamableElements("Template", ActionTemplates);
using (s.EnterCursorBookmark("Actions"))
s.StreamableElements("Action", Actions);
if (s.IsReading)
{
mConditionTypeBitLength = Bits.GetMaxEnumBits(Conditions.Count);
mActionTypeBitLength = Bits.GetMaxEnumBits(Actions.Count);
Conditions.ForEach(cond => NameToConditionMap.Add(cond.Name, cond));
Actions.ForEach(action => NameToActionMap.Add(action.Name, action));
TeamDesignatorValueType = NameToValueType["TeamDesignator"];
ObjectTypeIndexValueType = NameToValueType["ObjectTypeIndex"];
ForEachAction = NameToActionMap["for_each"];
if (Limits.SupportsVirtualTriggers)
{
BeginAction = NameToActionMap["begin"];
}
ObjectReferenceWithPlayerVarIndex.Initialize(this);
}
}
}
