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;
}
}
