internal static bool SerializeId <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s, string attributeName, ref int engineId, bool isOptional = false) where TDoc : class where TCursor : class { bool streamed = true; if (isOptional) { streamed = s.StreamAttributeOptIdAsString(attributeName, ref engineId, null, EngineIdResolver, EngineNameResolver, Predicates.IsNotNullOrEmpty); if (!streamed && s.IsReading) { engineId = TypeExtensions.kNone; } } else { s.StreamAttributeIdAsString(attributeName, ref engineId, null, EngineIdResolver, EngineNameResolver); } return(streamed); }
// #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); } }
internal void SerializeStringTableIndex <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s, string attributeName, ref int stringIndex) where TDoc : class where TCursor : class { if ((TagElementStreamSerializeFlags & GameEngineMegaloVariantTagElementStreamFlags.UseStringTableNames) != 0) { s.StreamAttributeIdAsString(attributeName, ref stringIndex, this, StringTableEntryIdResolver, StringTableEntryNameResolver); } else { s.StreamAttribute(attributeName, ref stringIndex); } }
internal static void SerializeValue <TDoc, TCursor>(MegaloScriptModel model, IO.TagElementStream <TDoc, TCursor, string> s, MegaloScriptValueType valueType, ref uint value, IO.TagElementNodeType nodeType = IO.TagElementNodeType.Text, string nodeName = null) where TDoc : class where TCursor : class { Contract.Requires(valueType.BaseType == MegaloScriptValueBaseType.Flags); if ((model.TagElementStreamSerializeFlags & MegaloScriptModelTagElementStreamFlags.UseEnumNames) != 0) { var id_resolving_ctxt = new Proto.MegaloScriptEnum.FlagsNameResolvingContext(model.Database, valueType); var id_resolver = Proto.MegaloScriptEnum.FlagsNameResolvingContext.IdResolver; var name_resolver = Proto.MegaloScriptEnum.FlagsNameResolvingContext.NameResolver; switch (nodeType) { case IO.TagElementNodeType.Element: s.StreamElementIdAsString(nodeName, ref value, id_resolving_ctxt, id_resolver, name_resolver); break; case IO.TagElementNodeType.Attribute: s.StreamAttributeIdAsString(nodeName, ref value, id_resolving_ctxt, id_resolver, name_resolver); break; case IO.TagElementNodeType.Text: s.StreamCursorIdAsString(ref value, id_resolving_ctxt, id_resolver, name_resolver); break; } } else { switch (nodeType) { case IO.TagElementNodeType.Element: s.StreamElement(nodeName, ref value); break; case IO.TagElementNodeType.Attribute: s.StreamAttribute(nodeName, ref value); break; case IO.TagElementNodeType.Text: s.StreamCursor(ref value); break; } } }
void Serialize <TDoc, TCursor>(MegaloScriptModel model, IO.TagElementStream <TDoc, TCursor, string> s, Proto.MegaloScriptProtoVariableReference protoType) where TDoc : class where TCursor : class { const string kTypeAttributeName = "varRefType"; if ((model.TagElementStreamSerializeFlags & MegaloScriptModelTagElementStreamFlags.UseEnumNames) != 0) { s.StreamAttributeIdAsString(kTypeAttributeName, ref Type, protoType, ToMemberIndex, FromMemberIndex); } else { s.StreamAttribute(kTypeAttributeName, ref Type); } var member = protoType.Members[Type]; if (member.HasDataType) { MegaloScriptEnumValue.SerializeValue(model, s, member.EnumValueType, ref DataType, IO.TagElementNodeType.Attribute, "dataType"); } else { DataType = TypeExtensions.kNone; } if (member.HasDataValue) { SerializeData(model, s, member.ValueType); } else { Data = TypeExtensions.kNone; } }
public void StreamPlayerVarIndex <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s, ref int playerVarIndex, int refTypeIndex, Model.MegaloScriptModel model) where TDoc : class where TCursor : class { const string kAttributeNamePlayerVarIndex = "playerVarIndex"; if ((model.TagElementStreamSerializeFlags & Model.MegaloScriptModelTagElementStreamFlags.UseIndexNames) != 0) { var varIndexType = GetPlayerVarIndexValueType(refTypeIndex); var resolving_ctxt = new Model.MegaloScriptModelVariableSet.IndexNameResolvingContext(model, varIndexType.VarSet, varIndexType.VarType, supportNone: true); s.StreamAttributeIdAsString(kAttributeNamePlayerVarIndex, ref playerVarIndex, resolving_ctxt, Model.MegaloScriptModelVariableSet.IndexNameResolvingContext.IdResolver, Model.MegaloScriptModelVariableSet.IndexNameResolvingContext.NameResolver); } else { s.StreamAttribute(kAttributeNamePlayerVarIndex, ref playerVarIndex); } Contract.Assert(ValidatePlayerVarIndex(playerVarIndex, refTypeIndex, model)); }
internal bool SerializeEnumTypeReference <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s, string attributeName, ref int enumIndex, bool isOptional = false) where TDoc : class where TCursor : class { bool streamed = true; if (isOptional) { streamed = s.StreamAttributeOptIdAsString(attributeName, ref enumIndex, this, kEnumIdResolver, kEnumNameResolver, Predicates.IsNotNullOrEmpty); if (!streamed && s.IsReading) { enumIndex = TypeExtensions.kNone; } } else { s.StreamAttributeIdAsString(attributeName, ref enumIndex, this, kEnumIdResolver, kEnumNameResolver); } return(streamed); }
internal static void SerializeValue <TDoc, TCursor>(MegaloScriptModel model, IO.TagElementStream <TDoc, TCursor, string> s, MegaloScriptValueType valueType, ref int value, IO.TagElementNodeType nodeType = IO.TagElementNodeType.Text, string nodeName = null) where TDoc : class where TCursor : class { Contract.Requires(valueType.BaseType == MegaloScriptValueBaseType.Index); var target = valueType.IndexTarget; if ((model.TagElementStreamSerializeFlags & MegaloScriptModelTagElementStreamFlags.EmbedObjects) != 0 && target == MegaloScriptValueIndexTarget.Trigger) { SerializeTriggerReferenceValue(model, s, valueType, ref value); } #region UseIndexNames else if ((model.TagElementStreamSerializeFlags & MegaloScriptModelTagElementStreamFlags.UseIndexNames) != 0 && target.HasIndexName()) { var id_resolving_ctxt = new MegaloScriptModel.IndexNameResolvingContext(model, target); var id_resolver = MegaloScriptModel.IndexNameResolvingContext.IdResolver; var name_resolver = MegaloScriptModel.IndexNameResolvingContext.NameResolver; switch (nodeType) { case IO.TagElementNodeType.Element: s.StreamElementIdAsString(nodeName, ref value, id_resolving_ctxt, id_resolver, name_resolver); break; case IO.TagElementNodeType.Attribute: s.StreamAttributeIdAsString(nodeName, ref value, id_resolving_ctxt, id_resolver, name_resolver); break; case IO.TagElementNodeType.Text: s.StreamCursorIdAsString(ref value, id_resolving_ctxt, id_resolver, name_resolver); break; } } #endregion else { switch (nodeType) { case IO.TagElementNodeType.Element: s.StreamElement(nodeName, ref value); break; case IO.TagElementNodeType.Attribute: s.StreamAttribute(nodeName, ref value); break; case IO.TagElementNodeType.Text: s.StreamCursor(ref value); break; } } // #REVIEW_BLAM: this will fail when embedding and the target is a Trigger since we don't preload triggers or such if (s.IsReading && ((model.TagElementStreamSerializeFlags & MegaloScriptModelTagElementStreamFlags.EmbedObjects) == 0 || target != MegaloScriptValueIndexTarget.Trigger) ) { if (!model.IndexTargetIsValid(target, valueType.IndexTraits, value)) { s.ThrowReadException(new System.IO.InvalidDataException(string.Format(Util.InvariantCultureInfo, "A {0} reference has an invalid value {1}", target, value))); } } }
static void SerializeValueType <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s, MegaloScriptDatabase db, ref MegaloScriptValueType value) where TDoc : class where TCursor : class { bool reading = s.IsReading; var base_type = reading ? MegaloScriptValueBaseType.None : value.BaseType; string name = reading ? null : db.ValueTypeNames[value.NameIndex]; int bit_length = reading ? 0 : value.BitLength; s.StreamAttributeEnum("baseType", ref base_type); s.StreamAttribute("name", ref name); bool has_bit_length = s.StreamAttributeOpt("bitLength", ref bit_length, Predicates.IsNotZero); int name_index = reading ? db.ValueTypeNames.Count : -1; if (reading) { db.ValueTypeNames.Add(name); } switch (base_type) { #region MegaloScriptValueBaseType.None case MegaloScriptValueBaseType.None: if (reading) { Contract.Assert(name_index == 0, "There should only be one None value type and it should come first"); Contract.Assert(db.ValueTypeNames[name_index] == kNoValueTypeName, "None value type is using non-standard name"); value = new MegaloScriptValueType(name_index, base_type, 0); } break; #endregion #region MegaloScriptValueBaseType.Single case MegaloScriptValueBaseType.Single: { int encoding_index = reading ? 0 : value.EncodingIndex; s.StreamAttributeIdAsString("encoding", ref encoding_index, db, (_db, str) => _db.SingleEncodings.FindIndex((x) => str.Equals(x.Name)), (_db, id) => _db.SingleEncodings[id].Name); if (reading) // #NOTE_BLAM: requires -1 when reading the TypeParam as the encoding index { value = new MegaloScriptValueType(name_index, base_type, bit_length, (uint)(encoding_index + 1)); } } break; #endregion #region MegaloScriptValueBaseType.Point3d case MegaloScriptValueBaseType.Point3d: { if (!has_bit_length) { throw new System.IO.InvalidDataException(string.Format("Point3d {0} didn't define a bit-length", name)); } bool is_signed = reading ? false : value.PointIsSigned; s.StreamAttributeOpt("signed", ref is_signed, Predicates.IsTrue); if (reading) { value = new MegaloScriptValueType(name_index, base_type, bit_length, 0, is_signed ? 1U : 0U); } } break; #endregion #region MegaloScriptValueBaseType.Flags case MegaloScriptValueBaseType.Flags: { int enum_index = reading ? 0 : value.EnumIndex; MegaloScriptValueEnumTraits enum_traits = reading ? 0 : value.EnumTraits; db.SerializeEnumTypeReference(s, "enumType", ref enum_index); if (reading) { if (!has_bit_length) { bit_length = db.Enums[enum_index].Members.Count; } value = new MegaloScriptValueType(name_index, base_type, bit_length, (uint)enum_index); } } break; #endregion #region MegaloScriptValueBaseType.Enum case MegaloScriptValueBaseType.Enum: { int enum_index = reading ? 0 : value.EnumIndex; MegaloScriptValueEnumTraits enum_traits = reading ? 0 : value.EnumTraits; db.SerializeEnumTypeReference(s, "enumType", ref enum_index); s.StreamAttributeEnumOpt("enumTraits", ref enum_traits, e => e != MegaloScriptValueEnumTraits.None); if (reading) { if (!has_bit_length) { int max_value = db.Enums[enum_index].Members.Count; if (enum_traits == MegaloScriptValueEnumTraits.HasNoneMember) { max_value++; } bit_length = Bits.GetMaxEnumBits(max_value); } value = new MegaloScriptValueType(name_index, bit_length, enum_index, enum_traits); } } break; #endregion #region MegaloScriptValueBaseType.Index case MegaloScriptValueBaseType.Index: { MegaloScriptValueIndexTarget index = reading ? MegaloScriptValueIndexTarget.Undefined : value.IndexTarget; MegaloScriptValueIndexTraits index_traits = reading ? 0 : value.IndexTraits; s.StreamAttributeEnum("indexTarget", ref index); s.StreamAttributeEnum("indexTraits", ref index_traits); if (reading) { // #NOTE_BLAM: If we for whatever reason wrote the DB back out, types with implicit bit lengths // would have that length written where they didn't before if (!has_bit_length) { bit_length = db.Limits.GetIndexTargetBitLength(index, index_traits); } value = new MegaloScriptValueType(name_index, bit_length, index, index_traits); } } break; #endregion #region MegaloScriptValueBaseType.Var case MegaloScriptValueBaseType.Var: { MegaloScriptVariableType var_type = reading ? 0 : value.VarType; MegaloScriptVariableSet var_set = reading ? 0 : value.VarSet; s.StreamAttributeEnum("varType", ref var_type); s.StreamAttributeEnum("varSet", ref var_set); if (reading) { // #NOTE_BLAM: If we for whatever reason wrote the DB back out, types with implicit bit lengths // would have that length written where they didn't before if (!has_bit_length) { bit_length = db.GetVariableIndexBitLength(var_set, var_type); } value = new MegaloScriptValueType(name_index, bit_length, var_type, var_set); } } break; #endregion #region MegaloScriptValueBaseType.VarReference case MegaloScriptValueBaseType.VarReference: { MegaloScriptVarReferenceType var_ref = reading ? 0 : value.VarReference; s.StreamAttributeEnum("varReferenceType", ref var_ref); if (reading) { value = new MegaloScriptValueType(name_index, var_ref); } } break; #endregion #region MegaloScriptValueBaseType.Tokens case MegaloScriptValueBaseType.Tokens: { int max_tokens = reading ? 0 : value.MaxTokens; s.StreamAttribute("maxTokens", ref max_tokens); if (reading) { bit_length = Bits.GetMaxEnumBits(max_tokens + 1); value = new MegaloScriptValueType(name_index, base_type, bit_length, (uint)max_tokens); } } break; #endregion #region MegaloScriptValueBaseType.ObjectReferenceWithPlayerVarIndex case MegaloScriptValueBaseType.ObjectReferenceWithPlayerVarIndex: { if (reading) { value = new MegaloScriptValueType(name_index, MegaloScriptVarReferenceType.Object, MegaloScriptValueBaseType.ObjectReferenceWithPlayerVarIndex); } } break; #endregion default: if (reading) { value = new MegaloScriptValueType(name_index, base_type, bit_length); } break; } }