public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var build = s.IsWriting ? BuildHandle : Engine.EngineBuildHandle.None;
using (s.EnterCursorBookmark("Game"))
Engine.EngineBuildHandle.Serialize(s, ref build);
if (s.IsReading)
{
// #TODO_BLAM: validate build handle?
BuildHandle = build;
}
s.StreamElementEnum("Content", ref Type);
s.StreamElement("TimeStamp", ref Timestamp);
s.WriteComment(this, _this => _this.Timestamp.ToString(System.Globalization.CultureInfo.InvariantCulture));
s.StreamElement("SessionSalt", ref SessionSalt, NumeralBase.Hex);
SerializeActivity(s);
s.StreamElementEnum("Engine", ref EngineType);
s.StreamAttributeOpt("unk4_", ref unk4, Predicates.IsNotNone);
s.StreamAttributeOpt("megaloCategory", ref MegaloCategoryIndex, Predicates.IsNotNone);
s.StreamAttributeOpt("engineIcon", ref EngineIconIndex, Predicates.IsNotNone);
s.StreamAttribute("unkA_", ref unkA);
s.StreamAttribute("unkB_", ref unkB);
s.StreamElement("Author", ref Author);
}
protected static void StreamValue <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s,
string valueName, ref string value,
bool useInnerText, bool useElement, bool internValue, bool toLower)
where TDoc : class
where TCursor : class
{
if (useInnerText)
{
s.StreamCursor(ref value);
}
else if (useElement)
{
s.StreamElement(valueName, ref value);
}
else if (valueName != null)
{
s.StreamAttribute(valueName, ref value);
}
if (s.IsReading)
{
if (toLower)
{
value = value.ToLowerInvariant();
}
if (internValue)
{
value = string.Intern(value);
}
}
}
void FromStream <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
foreach (var element in s.ElementsByName("Sound"))
{
using (s.EnterCursorBookmark(element))
{
string name = null; uint event_id = 0;
s.StreamElement("CueName", ref name);
s.StreamElement("CueIndex", ref event_id);
mEventsMap.Add(event_id, name);
}
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var model = (Model.MegaloScriptModel)s.Owner;
model.MegaloVariant.SerializeStringTableIndexOpt(s, "labelIndex", ref mLabelStringIndex);
SerializeCodeName(s);
s.StreamAttributeEnumOpt("params", ref mValidParameters, f => f != 0, true);
s.StreamAttributeOpt("min", ref mMinimum, Predicates.IsNotZero);
if (HasObjectTypeIndex)
{
Model.MegaloScriptIndexValue.SerializeValue(model, s, model.Database.ObjectTypeIndexValueType,
ref mObjectTypeIndex, IO.TagElementNodeType.Element, "ObjectType");
}
if (HasTeam)
{
Model.MegaloScriptEnumValue.SerializeValue(model, s, model.Database.TeamDesignatorValueType,
ref mTeam, IO.TagElementNodeType.Element, "Team");
}
if (HasNumeric)
{
s.StreamElement("Numeric", ref mNumeric);
}
}
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);
}
internal static void SerializeViaElement <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s,
string elementName, ref ListLimitTraits traits)
where TDoc : class
where TCursor : class
{
s.StreamElement(elementName, ref traits.MaxCount);
if (s.IsReading)
{
traits.InitializeBitLengths();
}
}
protected static void StreamValue <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s,
string valueName, ref int value,
bool useInnerText, bool useElement)
where TDoc : class
where TCursor : class
{
if (useInnerText)
{
s.StreamCursor(ref value);
}
else if (useElement)
{
s.StreamElement(valueName, ref value);
}
else if (valueName != null)
{
s.StreamAttribute(valueName, ref value);
}
}
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;
}
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var engine = KSoft.Debug.TypeCheck.CastReference <BlamEngine>(s.Owner);
if (s.IsReading)
{
Engine = engine;
}
else
{
Contract.Assert(engine == Engine);
}
using (s.EnterCursorBookmark("Repository"))
using (s.EnterUserDataBookmark(this))
{
s.StreamElement("Guid", this, obj => obj.Guid);
EngineTargetPlatform.SerializeBitSet(s, ref mValidTargetPlatforms, "ValidTargetPlatforms");
using (var bm = s.EnterCursorBookmarkOpt("Branches", Branches, Predicates.HasItems)) if (bm.IsNotNull)
{
s.StreamableElements("Branch", Branches);
}
}
if (s.IsReading)
{
KSoft.Debug.ValueCheck.IsLessThanEqualTo("Too many registered engine branches in " + Engine.Name,
EngineBuildBranch.kMaxCount, Branches.Count);
Branches.TrimExcess();
}
}
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)));
}
}
}
public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
var branch = KSoft.Debug.TypeCheck.CastReference <EngineBuildBranch>(s.UserData);
if (s.IsReading)
{
Branch = branch;
}
else
{
Contract.Assert(branch == Branch);
}
s.StreamAttribute("versionId", this, obj => obj.Version);
s.StreamAttribute("build", this, obj => obj.BuildString);
if (!s.StreamAttributeOpt("changeListId", this, obj => obj.ChangeList, Predicates.IsNotNone))
{
ChangeList = TypeExtensions.kNoneInt32;
}
if (!s.StreamAttributeEnumOpt("productionStage", this, obj => obj.ProductionStage))
{
ProductionStage = EngineProductionStage.Undefined;
}
if (!s.StreamAttributeEnumOpt("buildStringType", this, obj => obj.BuildStringType))
{
BuildStringType = EngineBuildStringType.Build_DateTime;
}
s.StreamElement("Date", ref mDateString);
s.StreamElement("Time", ref mTimeString);
if (!s.StreamAttributeOpt("exportName", this, obj => obj.ExportName, Predicates.IsNotNullOrEmpty))
{
ExportName = "";
}
EngineTargetPlatform.SerializeBitSet(s, ref mValidTargetPlatforms, "ValidTargetPlatforms");
if (s.IsReading)
{
const string k_date_format_string =
kDateFormat + " " +
kDateTimeFormat + " " +
kDateTimeOffsetFormat;
string date_time_str = string.Format(Util.InvariantCultureInfo,
"{0} {1}", mDateString, mTimeString);
try
{ DateTime.ParseExact(date_time_str, k_date_format_string, System.Globalization.CultureInfo.InvariantCulture); }
catch (FormatException ex)
{ s.ThrowReadException(ex); }
if (ValidTargetPlatforms == EngineRegistry.NullValidTargetPlatforms)
{
throw new System.IO.InvalidDataException(string.Format(Util.InvariantCultureInfo,
"{0}/{1} or its repository parents didn't specify any ValidTargetPlatforms",
Branch.Name, BuildString));
}
}
}
