public static ContentMiniMetadata Decode(Engine.EngineBuildHandle buildHandle, string containerName)
{
Contract.Requires <ArgumentNullException>(!string.IsNullOrEmpty(containerName));
Contract.Requires <ArgumentException>(containerName.Length <= kEncodedPortionLength + 1);
var result = Create(buildHandle);
result.Type = (ContentMiniMetadataType)containerName[0];
if (!result.Type.IsValid())
{
throw new ArgumentException("Unrecognized content type: " + containerName[0]);
}
string encoded_porition = containerName.Substring(1);
byte[] bits = kRadixEncoding.Decode(encoded_porition);
using (var ms = new System.IO.MemoryStream(bits))
using (var bs = new IO.BitStream(ms))
{
bs.StreamMode = System.IO.FileAccess.Read;
result.Serialize(bs);
}
return(result);
}
internal GameLanguageHandle(Engine.EngineBuildHandle buildHandle, int langIndex, int gameIndex)
{
Contract.Requires(LanguageRegistry.IsValidLanguageIndex(langIndex));
Contract.Requires(IsValidGameIndex(gameIndex));
InitializeHandle(out mHandle, buildHandle, langIndex, gameIndex);
}
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);
}
public BlobGroupVersionAndBuildInfo FindMostRelaventVersionInfo(Engine.EngineBuildHandle forBuild)
{
if (forBuild.IsNone)
{
throw new ArgumentNoneException(nameof(forBuild));
}
BlobGroupVersionAndBuildInfo exact_match = null;
BlobGroupVersionAndBuildInfo most_relevant = null;
int possibly_relevant_count = 0;
foreach (var kvp in VersionAndBuildMap)
{
var possible_info = kvp.Value;
// Solves for versions tied to a specific revision, if any
if (exact_match == null &&
possible_info.BuildHandle == forBuild)
{
exact_match = possible_info;
}
// Else, find the last one in the branch
if (forBuild.IsWithinSameBranch(possible_info.BuildHandle))
{
most_relevant = possible_info;
possibly_relevant_count++;
}
}
return(exact_match ?? most_relevant);
}
public bool IsSpecificBuildSupported(Engine.EngineBuildHandle forBuild, out Engine.EngineBuildHandle actualBuild)
{
var files = BuildProtoFiles.Empty;
forBuild.TryGetValue(mBuildProtoFiles, ref files, out actualBuild);
return(!files.IsEmpty);
}
public Task <MegaloScriptDatabase> GetMegaloDatabaseAsync(Engine.EngineBuildHandle forBuild)
{
Contract.Requires <ArgumentNullException>(!forBuild.IsNone);
return(GetDatabaseAsync(forBuild, "script",
GetMegaloDatabasePath, mLoadedScriptDbs,
actualBuild => new MegaloScriptDatabase(actualBuild)));
}
internal static GameLanguageTable GetGameLanguageTable(Engine.EngineBuildHandle forBuild)
{
Contract.Requires(!forBuild.IsNone);
using (var system_ref = Blam.Engine.EngineRegistry.GetSystem <LanguageSystem>(forBuild))
{
var system = system_ref.System;
return(system.GetLanguageTable(forBuild));
}
}
public GameOptionsTeamOptionsHalo4(Engine.EngineBuildHandle h4Build)
{
mHalo4Build = h4Build;
mTeams = new GameOptionsSingleTeamOptionsHalo4[8];
for (int x = 0; x < Teams.Length; x++)
{
Teams[x] = new GameOptionsSingleTeamOptionsHalo4(h4Build);
}
}
internal static ContentHeader Create(Engine.EngineBuildHandle gameBuild)
{
if (gameBuild.IsWithinSameBranch(Engine.EngineRegistry.EngineBranchHaloReach))
return new Games.HaloReach.RuntimeData.ContentHeaderHaloReach(gameBuild);
if (gameBuild.IsWithinSameBranch(Engine.EngineRegistry.EngineBranchHalo4))
return new Games.Halo4.RuntimeData.ContentHeaderHalo4(gameBuild);
throw new KSoft.Debug.UnreachableException(gameBuild.ToDisplayString());
}
public GameOptionsTeamOptionsHaloReach(Engine.EngineBuildHandle reachBuild)
{
mReachBuild = reachBuild;
mTeams = new GameOptionsSingleTeamOptionsHaloReach[8];
for (int x = 0; x < Teams.Length; x++)
{
mTeams[x] = new GameOptionsSingleTeamOptionsHaloReach(reachBuild);
}
}
// For simple queries only! Don't hold on to the value
internal static Task <MegaloScriptDatabase> GetScriptDatabaseAsync(Engine.EngineBuildHandle gameBuild)
{
Contract.Requires(!gameBuild.IsNone);
using (var system_ref = Blam.Engine.EngineRegistry.GetSystem <MegaloProtoSystem>(gameBuild))
{
var system = system_ref.System;
return(system.GetMegaloDatabaseAsync(gameBuild));
}
}
void EnumerateChunksReadObjectFoundBuildIncompatibility(BlobSystem blobSystem,
BlobChunkHeader header, BlobGroup blobGroup,
Engine.EngineBuildHandle buildForBlobVersion, Engine.EngineBuildHandle actualBuild)
{
throw new InvalidOperationException(string.Format(
"Build incompatibility for chunk {0} v{1} sizeof({2}) which uses build={3} " +
"but we're using build={4} for {5}",
blobGroup.GroupTag.TagString, header.Version, header.DataSize, buildForBlobVersion.ToDisplayString(),
actualBuild.ToDisplayString(), UnderlyingStream.StreamName));
}
public string GetMegaloDatabasePath(Engine.EngineBuildHandle forBuild, out Engine.EngineBuildHandle actualBuild)
{
Contract.Requires <ArgumentNullException>(!forBuild.IsNone);
var files = BuildProtoFiles.Empty;
forBuild.TryGetValue(mBuildProtoFiles, ref files, out actualBuild);
return(files.MegaloDatabaseFile);
}
public Task <MegaloStaticDatabase> GetStaticDatabaseAsync(Engine.EngineBuildHandle forBuild)
{
Contract.Requires <ArgumentNullException>(!forBuild.IsNone);
return(GetDatabaseAsync(forBuild, "static",
GetStaticDatabasePath, mLoadedStaticDbs,
actualBuild => {
var mdb = GetMegaloDatabaseAsync(actualBuild);
return new MegaloStaticDatabase(actualBuild, mdb.Result.Limits);
}));
}
public AllDatabasesTasksTuple GetAllDatabasesAsync(Engine.EngineBuildHandle forBuild)
{
Contract.Requires <ArgumentNullException>(!forBuild.IsNone);
var static_db_task = GetStaticDatabaseAsync(forBuild);
var megalo_db_task = GetMegaloDatabaseAsync(forBuild);
return(new AllDatabasesTasksTuple
(static_db_task
, megalo_db_task
));
}
static Exception SerializeObjectFoundBuildIncompatibility(BlobSystem blobSystem,
BlobGroup blobGroup, int version,
Engine.EngineBuildHandle buildForBlobVersion, Engine.EngineBuildHandle actualBuild)
{
var msg = string.Format(
"Build incompatibility for blob object {0} v{1} which uses build={2} " +
"but stream uses build={3}",
blobGroup.GroupTag.TagString, version, buildForBlobVersion.ToDisplayString(),
actualBuild.ToDisplayString());
return(new System.IO.InvalidDataException(msg));
}
public static ContentMiniMetadata Create(Engine.EngineBuildHandle gameBuild)
{
if (gameBuild.IsWithinSameBranch(Engine.EngineRegistry.EngineBranchHaloReach))
{
return(new Games.HaloReach.RuntimeData.ContentMiniMetadataHaloReach(gameBuild));
}
if (gameBuild.IsWithinSameBranch(Engine.EngineRegistry.EngineBranchHalo4))
{
return(new Games.Halo4.RuntimeData.ContentMiniMetadataHalo4(gameBuild));
}
throw new KSoft.Debug.UnreachableException(gameBuild.ToDisplayString());
}
public GameLanguageTable GetLanguageTable(Engine.EngineBuildHandle forBuild)
{
#if LANGUAGE_SYSTEM_USE_ONLY_ONE_TABLE
Contract.Requires <ArgumentNullException>(!forBuild.IsNone);
Contract.Assert(forBuild.EngineIndex == mEngineTable.BuildHandle.EngineIndex);
return(mEngineTable);
#else
GameLanguageTable engine_table = null;
forBuild.TryGetValue(mEngineTables, ref engine_table);
return(engine_table);
#endif
}
//internal uint Handle { get { return mHandle; } }
static void InitializeHandle(out uint handle,
Engine.EngineBuildHandle buildHandle, int langIndex, int gameIndex)
{
uint is_supported = gameIndex.IsNotNone() ? 1U : 0U;
var encoder = new Bitwise.HandleBitEncoder();
encoder.EncodeNoneable32(gameIndex, Constants.kGameIndexBitField);
encoder.Encode32(is_supported, Constants.kIsSupportedBitField);
LanguageRegistry.BitEncodeLanguageIndex(ref encoder, langIndex);
encoder.Encode32(buildHandle.Handle, Constants.kBuildBitField);
Contract.Assert(encoder.UsedBitCount == GameLanguageHandle.BitCount);
handle = encoder.GetHandle32();
}
internal MegaloStaticDatabase(Engine.EngineBuildHandle forBuild, EngineLimits limits)
{
EngineBuild = forBuild;
mLimits = limits;
MultiplayerEffects = new List <MultiplayerEffect>();
ObjectTypeList = new MultiplayerObjectTypeList(limits);
CustomApps = new List <UnitCustomApp>();
OrdnanceList = new GameGlobalsOrdnanceList(limits);
Medals = new List <GameMedal>(limits.GameMedals.MaxCount);
Incidents = new List <GameIncident>(limits.GameIncidentTypes.MaxCount);
HudWidgetIcons = new List <MegaloHudWidgetIcon>(limits.MegaloHudWidgetIcons.MaxCount);
GameEngineIcons = new List <GameEngineIcon>(limits.GameEngineIcons.MaxCount);
Sounds = new List <MegaloEngineSound>(limits.MegaloEngineSounds.MaxCount);
Names = new List <MegaloEngineStringId>(limits.MegaloStringIds.MaxCount);
}
public MegaloScriptDatabase(Engine.EngineBuildHandle forBuild)
{
EngineBuild = forBuild;
Limits = new EngineLimits();
SingleEncodings = new List <SingleEncoding>();
Enums = new List <MegaloScriptEnum>();
ValueTypeNames = new List <string>();
ValueTypes = new List <MegaloScriptValueType>();
Conditions = new List <MegaloScriptProtoCondition>();
ActionTemplates = new List <MegaloScriptProtoActionTemplate>();
Actions = new List <MegaloScriptProtoAction>();
VariableRefTypes = new Dictionary <MegaloScriptVariableReferenceType, MegaloScriptProtoVariableReference>();
VariableSets = new Dictionary <MegaloScriptVariableSet, MegaloScriptProtoVariableSet>();
NameToValueType = new Dictionary <string, MegaloScriptValueType>();
NameToConditionMap = new Dictionary <string, MegaloScriptProtoCondition>();
NameToActionMap = new Dictionary <string, MegaloScriptProtoAction>();
ImportCodeEnum <MegaloScriptComparisonType> ("ComparisonType");
ImportCodeEnum <MegaloScriptOperationType> ("OperationType");
ImportCodeEnum <RuntimeData.GameTeamDesignator> ("TeamDesignator");
ImportCodeEnum <GameEngineTimerRate> ("TimerRate");
ImportCodeEnum <MegaloScriptNavpointIconType> ("NavpointIconType");
ImportCodeEnum <MegaloScriptDamageReportingModifier> ("DamageReportingModifier");
if (forBuild.IsChildOf(Engine.EngineRegistry.EngineBranchHaloReach.BranchHandle))
{
InitializeForHaloReach();
}
else if (forBuild.IsChildOf(Engine.EngineRegistry.EngineBranchHalo4.BranchHandle))
{
InitializeForHalo4();
}
else
{
Contract.Assert(false);
throw new KSoft.Debug.UnreachableException(string.Format(
"Failed to handle build: {0}",
forBuild));
}
}
static async Task <T> GetDatabaseAsync <T>(Engine.EngineBuildHandle forBuild,
string dbTypeName,
GetDatabasePathFunc getPathFunc,
Dictionary <string, T> loadedDbs,
Func <Engine.EngineBuildHandle, T> ctor)
where T : class, IO.ITagElementStringNameStreamable
{
Contract.Requires/*<ArgumentNullException>*/ (!forBuild.IsNone);
Contract.Requires(!string.IsNullOrEmpty(dbTypeName));
Contract.Requires(getPathFunc != null);
Contract.Requires(loadedDbs != null);
Engine.EngineBuildHandle actual_build;
string path = getPathFunc(forBuild, out actual_build);
if (path == null)
{
throw new InvalidOperationException(string.Format(
"Tried to get the megalo {0} database for {1} when a build file wasn't defined for it",
dbTypeName,
forBuild.ToDisplayString()));
}
T db;
lock (loadedDbs)
loadedDbs.TryGetValue(path, out db);
if (db == null)
{
db = ctor(actual_build);
lock (loadedDbs)
loadedDbs[path] = db;
await Task.Run(() => LoadDatabase(db, path));
}
return(db);
}
public ContentHeaderHalo4(Engine.EngineBuildHandle h4Build) : base(h4Build)
{
}
public ContentHeaderHaloReach(Engine.EngineBuildHandle reachBuild) : base(reachBuild)
{
}
public GameEngineVariant(Engine.EngineBuildHandle gameBuild, GameEngineType type)
{
mGameBuild = gameBuild;
mType = type;
InitializeVariant();
}
public ContentMiniMetadataHaloReach(Engine.EngineBuildHandle buildHandle) : base(buildHandle)
{
}
public bool IsSpecificBuildSupported(Engine.EngineBuildHandle forBuild)
{
Engine.EngineBuildHandle actual_build;
return(IsSpecificBuildSupported(forBuild, out actual_build));
}
protected ContentHeader(Engine.EngineBuildHandle gameBuild)
{
GameBuild = gameBuild;
Creator = new ContentAuthor();
Modifier = new ContentAuthor();
}
internal LocaleStringTable(LocaleStringTableInfo info, Engine.EngineBuildHandle buildHandle)
{
kInfo = info;
mStringReferences = new List <LocaleStringTableReference>();
mEngineLanguageTable = LanguageSystem.GetGameLanguageTable(buildHandle);
}
public GameOptionsSingleTeamOptionsHalo4(Engine.EngineBuildHandle h4Build)
: base(h4Build, kNameStringTableInfo)
{
RevertToDefault();
}
