public void Init(STUMapHeader mapHeader, ulong key = default)
{
GUID = (teResourceGUID)key;
Name = GetString(mapHeader.m_displayName);
VariantName = GetString(mapHeader.m_1C706502);
Description = GetString(mapHeader.m_389CB894);
Description2 = GetString(mapHeader.m_ACB95597);
Subline = GetString(mapHeader.m_EBCFAD22);
StateA = GetString(mapHeader.m_8EBADA44);
StateB = GetString(mapHeader.m_5AFE2F61);
MapGUID = mapHeader.m_map;
State = mapHeader.m_A125818B;
MapType = mapHeader.m_mapType;
GameModes = mapHeader.m_D608E9F3?.Select(x => new GameMode(x).ToLite()).Where(x => x.GUID != 0);
}
public void SaveMaps(ICLIFlags toolFlags)
{
string basePath;
if (toolFlags is ExtractFlags flags)
{
basePath = flags.OutputPath;
}
else
{
throw new Exception("no output path");
}
Dictionary <string, Dictionary <string, ParsedArg> > parsedTypes = ParseQuery(flags, QueryTypes, QueryNameOverrides);
if (parsedTypes == null)
{
QueryHelp(QueryTypes);
return;
}
foreach (ulong key in TrackedFiles[0x9F])
{
STUMapHeader map = GetInstance <STUMapHeader>(key);
if (map == null)
{
continue;
}
MapHeader mapInfo = ListMaps.GetMap(key);
mapInfo.Name = mapInfo.Name ?? "Title Screen";
Dictionary <string, ParsedArg> config = GetQuery(parsedTypes, mapInfo.Name, mapInfo.VariantName,
mapInfo.GetUniqueName(), mapInfo.GetName(), teResourceGUID.Index(map.m_map).ToString("X"), "*");
if (config.Count == 0)
{
continue;
}
Map.Save(flags, mapInfo, map, key, basePath);
SaveScratchDatabase();
}
}
public void Parse(ICLIFlags toolFlags)
{
var flags = toolFlags as ExtractFlags;
var testguids = flags.Positionals.Skip(3).Select(x => uint.Parse(x, System.Globalization.NumberStyles.HexNumber));
foreach (var guid in Program.TrackedFiles[0x9F])
{
if (testguids.Contains(teResourceGUID.Index(guid)))
{
var path = Path.Combine(flags.OutputPath, "teMapPlacable", teResourceGUID.Index(guid).ToString("X"));
STUMapHeader map = GetInstance <STUMapHeader>(guid);
foreach (var t in Enum.GetValues(typeof(Enums.teMAP_PLACEABLE_TYPE)))
{
var teType = (Enums.teMAP_PLACEABLE_TYPE)t;
if (teType == Enums.teMAP_PLACEABLE_TYPE.UNKNOWN)
{
continue;
}
var o = Path.Combine(path, teType.ToString());
if (teMapPlaceableData.Manager.Types.ContainsKey(teType))
{
continue;
}
if (!Directory.Exists(o))
{
Directory.CreateDirectory(o);
}
teMapPlaceableData placable = GetPlaceableData(map, teType);
for (int i = 0; i < placable.Header.PlaceableCount; ++i)
{
var commonStructure = placable.CommonStructures[i];
using (var f = File.OpenWrite(Path.Combine(o, commonStructure.UUID.Value.ToString("N")))) {
f.Write(((teMapPlaceableDummy)placable.Placeables[i]).Data, 0, ((teMapPlaceableDummy)placable.Placeables[i]).Data.Length);
}
}
}
}
}
}
public void Init(STUMapHeader mapHeader, ulong key = default)
{
GUID = (teResourceGUID)key;
Name = GetString(mapHeader.m_displayName);
VariantName = GetString(mapHeader.m_1C706502);
Description = GetString(mapHeader.m_389CB894);
Description2 = GetString(mapHeader.m_ACB95597);
Subline = GetString(mapHeader.m_EBCFAD22);
StateA = GetString(mapHeader.m_8EBADA44);
StateB = GetString(mapHeader.m_5AFE2F61);
MapGUID = mapHeader.m_map;
State = mapHeader.m_A125818B;
MapType = mapHeader.m_mapType;
Thumbnail = mapHeader.m_9386E669;
Image = mapHeader.m_86C1CFAB;
FlagImage = mapHeader.m_C6599DEB;
GameModes = mapHeader.m_D608E9F3?.Select(x => new GameMode(x).ToLite()).Where(x => x.GUID != 0);
if (mapHeader.m_celebrationOverrides != null)
{
CelebrationVariants = mapHeader.m_celebrationOverrides.Select(x => {
var hmm = (teResourceGUID)x.m_map;
hmm.SetType(0x9F);
return(new MapCelebrationVariant {
Name = GetGUIDName(x.m_celebrationType),
Virtual01C = x.m_celebrationType,
MapInfo = new MapHeader(hmm).ToLite()
});
}).ToArray();
}
// Attempt to get the menu map name if one exists
var mapHeaderGuid = (teResourceGUID)mapHeader.m_map;
mapHeaderGuid.SetType(0x9F);
Name = GetNullableGUIDName(mapHeaderGuid) ?? Name;
}
public MapHeader(STUMapHeader stu, ulong key = default)
{
Init(stu, key);
}
public void SaveMaps(ICLIFlags toolFlags)
{
string basePath;
if (toolFlags is ExtractFlags extractFlags)
{
basePath = extractFlags.OutputPath;
}
else
{
throw new Exception("no output path");
}
basePath = Path.Combine(basePath, "Environments");
if (!Directory.Exists(basePath))
{
Directory.CreateDirectory(basePath);
}
var flags = extractFlags as ExtractMapEnvFlags ?? new ExtractMapEnvFlags();
if (!flags.SkipMapEnvironmentLUT && File.Exists(Path.Combine(basePath, "SPILUT", "config.ocio")))
{
File.Delete(Path.Combine(basePath, "SPILUT", "config.ocio"));
}
HashSet <KeyValuePair <ulong, string> > done = new HashSet <KeyValuePair <ulong, string> >();
foreach (ulong metaKey in TrackedFiles[0x9F])
{
STUMapHeader map = GetInstance <STUMapHeader>(metaKey);
if (map == null)
{
continue;
}
MapHeader mapInfo = GetMap(metaKey);
ulong dataKey = map.m_map;
//if (teResourceGUID.Index(dataKey) != 0x7A4) continue;
var mapName = GetValidFilename($"{mapInfo.GetName()}_{teResourceGUID.Index(mapInfo.MapGUID):X}");
string fname = $"ow_map_{mapName}";
var reflectionData = Map.GetPlaceableData(map, Enums.teMAP_PLACEABLE_TYPE.REFLECTIONPOINT);
if (reflectionData != null)
{
foreach (var placeable in reflectionData.Placeables ?? Array.Empty <IMapPlaceable>())
{
if (!(placeable is teMapPlaceableReflectionPoint reflectionPoint))
{
continue;
}
if (done.Add(new KeyValuePair <ulong, string>(reflectionPoint.Header.Texture1, mapInfo.Name + "cube")))
{
SaveTex(extractFlags, basePath, Path.Combine("Cubemap", fname), reflectionPoint.Header.Texture1.ToString(), reflectionPoint.Header.Texture1);
}
if (done.Add(new KeyValuePair <ulong, string>(reflectionPoint.Header.Texture2, mapInfo.Name + "cube")))
{
SaveTex(extractFlags, basePath, Path.Combine("Cubemap", fname), reflectionPoint.Header.Texture2.ToString(), reflectionPoint.Header.Texture2);
}
}
}
using (Stream data = OpenFile(dataKey)) {
if (data != null)
{
using (BinaryReader dataReader = new BinaryReader(data)) {
teMap env = dataReader.Read <teMap>();
// using (Stream lightingStream = OpenFile(env.BakedLighting)) {
// teLightingManifest lightingManifest = new teLightingManifest(lightingStream);
//}
if (!flags.SkipMapEnvironmentSound && done.Add(new KeyValuePair <ulong, string>(env.MapEnvironmentSound, mapInfo.Name)))
{
SaveSound(extractFlags, basePath, Path.Combine("Sound", mapName), env.MapEnvironmentSound);
}
if (!flags.SkipMapEnvironmentLUT && done.Add(new KeyValuePair <ulong, string>(env.LUT, mapInfo.Name)))
{
SaveTex(extractFlags, basePath, "LUT", fname + env.LUT, env.LUT);
SaveLUT(extractFlags, basePath, "SPILUT", fname + env.LUT, env.LUT, Path.Combine(basePath, "SPILUT", "config.ocio"), mapInfo);
}
if (!flags.SkipMapEnvironmentBlendCubemap && done.Add(new KeyValuePair <ulong, string>(env.BlendEnvironmentCubemap, mapInfo.Name)))
{
SaveTex(extractFlags, basePath, "BlendCubemap", fname + env.BlendEnvironmentCubemap, env.BlendEnvironmentCubemap);
}
if (!flags.SkipMapEnvironmentGroundCubemap && done.Add(new KeyValuePair <ulong, string>(env.GroundEnvironmentCubemap, mapInfo.Name)))
{
SaveTex(extractFlags, basePath, "GroundCubemap", fname + env.GroundEnvironmentCubemap, env.GroundEnvironmentCubemap);
}
if (!flags.SkipMapEnvironmentSkyCubemap && done.Add(new KeyValuePair <ulong, string>(env.SkyEnvironmentCubemap, mapInfo.Name)))
{
SaveTex(extractFlags, basePath, "SkyCubemap", fname + env.SkyEnvironmentCubemap, env.SkyEnvironmentCubemap);
}
if (!flags.SkipMapEnvironmentSkybox && done.Add(new KeyValuePair <ulong, string>(env.SkyboxModel + env.SkyboxModelLook, mapInfo.Name)))
{
SaveMdl(extractFlags, basePath, Path.Combine("Skybox", mapName), env.SkyboxModel, env.SkyboxModelLook);
}
if (!flags.SkipMapEnvironmentEntity && done.Add(new KeyValuePair <ulong, string>(env.EntityDefinition, mapInfo.Name)))
{
SaveEntity(extractFlags, basePath, Path.Combine("Entity", mapName), env.EntityDefinition);
}
}
}
}
InfoLog("Saved Environment data for {0}", mapInfo.GetUniqueName());
}
}
public static teMapPlaceableData GetPlaceableData(STUMapHeader map, Enums.teMAP_PLACEABLE_TYPE modelGroup)
{
return(GetPlaceableData(map, (byte)modelGroup));
}
public static void Save(ICLIFlags flags, STUMapHeader mapHeader, ulong key, string basePath)
{
string name = GetString(mapHeader.m_displayName) ?? "Title Screen";
//string name = map.m_506FA8D8;
var variantName = GetString(mapHeader.m_1C706502);
if (variantName != null)
{
name = variantName;
}
LoudLog($"Extracting map {name}\\{teResourceGUID.Index(key):X}");
name = GetValidFilename(name);
// TODO: MAP11 HAS CHANGED
// TODO: MAP10 TOO?
string mapPath = Path.Combine(basePath, "Maps", name, teResourceGUID.Index(key).ToString("X")) + Path.DirectorySeparatorChar;
CreateDirectoryFromFile(mapPath);
FindLogic.Combo.ComboInfo info = new FindLogic.Combo.ComboInfo();
LoudLog("\tFinding");
FindLogic.Combo.Find(info, mapHeader.m_map);
//for (ushort i = 0; i < 255; i++) {
// using (Stream mapChunkStream = OpenFile(mapHeader.GetChunkKey((byte)i))) {
// if (mapChunkStream == null) continue;
// WriteFile(mapChunkStream, Path.Combine(mapPath, $"{(Enums.teMAP_PLACEABLE_TYPE)i}.0BC"));
// }
//}
//return;
teMapPlaceableData placeableModelGroups = GetPlaceableData(mapHeader, Enums.teMAP_PLACEABLE_TYPE.MODEL_GROUP);
teMapPlaceableData placeableSingleModels = GetPlaceableData(mapHeader, Enums.teMAP_PLACEABLE_TYPE.SINGLE_MODEL);
teMapPlaceableData placeableModel = GetPlaceableData(mapHeader, Enums.teMAP_PLACEABLE_TYPE.MODEL);
teMapPlaceableData placeableLights = GetPlaceableData(mapHeader, Enums.teMAP_PLACEABLE_TYPE.LIGHT);
teMapPlaceableData placeableEntities = GetPlaceableData(mapHeader, Enums.teMAP_PLACEABLE_TYPE.ENTITY);
teMapPlaceableData placeableSounds = GetPlaceableData(mapHeader, Enums.teMAP_PLACEABLE_TYPE.SOUND);
teMapPlaceableData placeableEffects = GetPlaceableData(mapHeader, Enums.teMAP_PLACEABLE_TYPE.EFFECT);
OverwatchMap exportMap = new OverwatchMap(name, info, placeableSingleModels, placeableModelGroups, placeableModel, placeableEntities, placeableLights, placeableSounds, placeableEffects);
using (Stream outputStream = File.OpenWrite(Path.Combine(mapPath, $"{name}.{exportMap.Extension}"))) {
exportMap.Write(outputStream);
}
{
FindLogic.Combo.Find(info, mapHeader.m_86C1CFAB);
FindLogic.Combo.Find(info, mapHeader.m_9386E669);
FindLogic.Combo.Find(info, mapHeader.m_C6599DEB);
if (mapHeader.m_D608E9F3 != null)
{
foreach (teResourceGUID gamemodeGUID in mapHeader.m_D608E9F3)
{
STUGameMode gameMode = GetInstance <STUGameMode>(gamemodeGUID);
if (gameMode == null)
{
continue;
}
FindLogic.Combo.Find(info, gameMode.m_6EB38130); // 004
FindLogic.Combo.Find(info, gameMode.m_CF63B633); // 01B
FindLogic.Combo.Find(info, gameMode.m_7F5B54B2); // game mode voice set
foreach (STUGameModeTeam team in gameMode.m_teams)
{
FindLogic.Combo.Find(info, team.m_bodyScript); // 01B
FindLogic.Combo.Find(info, team.m_controllerScript); // 01B
}
}
}
}
FindLogic.Combo.Find(info, mapHeader.m_announcerWelcome);
info.SetEffectName(mapHeader.m_announcerWelcome, "AnnouncerWelcome");
FindLogic.Combo.Find(info, mapHeader.m_musicTease);
info.SetEffectName(mapHeader.m_musicTease, "MusicTease");
ulong announcerVoiceSet = 0;
using (Stream stream = OpenFile(mapHeader.m_map)) {
if (stream != null)
{
using (BinaryReader reader = new BinaryReader(stream)) {
teMap map = reader.Read <teMap>();
STUVoiceSetComponent voiceSetComponent =
GetInstance <STUVoiceSetComponent>(map.EntityDefinition);
announcerVoiceSet = voiceSetComponent?.m_voiceDefinition;
FindLogic.Combo.Find(info, announcerVoiceSet);
info.SetEffectVoiceSet(mapHeader.m_announcerWelcome, announcerVoiceSet);
}
}
}
LoudLog("\tSaving");
Combo.Save(flags, mapPath, info);
Combo.SaveLooseTextures(flags, Path.Combine(mapPath, "Textures"), info);
if (mapHeader.m_7F5B54B2 != 0) // map voice set. not announcer
{
FindLogic.Combo.Find(info, mapHeader.m_7F5B54B2);
}
if (announcerVoiceSet != 0) // whole thing in env mode, not here
{
info.VoiceSets.Remove(announcerVoiceSet);
}
Combo.SaveAllVoiceSets(flags, Path.Combine(mapPath, "VoiceSets"), info);
Combo.SaveAllSoundFiles(flags, Path.Combine(mapPath, "Sound"), info);
LoudLog("\tDone");
}
public static ulong GetChunkRoot(this STUMapHeader w)
{
return((w.m_map & ~0xFFFFFFFF00000000ul) | 0x0DD0000100000000ul);
}
public static MapInfo GetMap(ulong key)
{
STUMapHeader map = GetInstance <STUMapHeader>(key);
if (map == null)
{
return(null);
}
string nameA = GetString(map.m_displayName);
string nameB = GetString(map.m_1C706502);
string subline = GetString(map.m_EBCFAD22);
string descA = GetString(map.m_389CB894);
string descB = GetString(map.m_ACB95597);
string stateA = GetString(map.m_5AFE2F61);
string stateB = GetString(map.m_8EBADA44);
List <GamemodeInfo> gamemodes = null;
if (map.m_D608E9F3 != null)
{
gamemodes = new List <GamemodeInfo>();
foreach (ulong guid in map.m_D608E9F3)
{
STUGameMode gamemode = GetInstance <STUGameMode>(guid);
if (gamemode == null)
{
continue;
}
gamemodes.Add(new GamemodeInfo {
Name = GetString(gamemode.m_displayName),
GUID = guid
});
}
}
// if (map.m_celebrationOverrides != null) {
//
//
// }
if (!string.IsNullOrEmpty(nameA) && !string.IsNullOrEmpty(nameB) && nameB.Equals(nameA))
{
nameB = null;
}
if (!string.IsNullOrEmpty(descA) && !string.IsNullOrEmpty(descB) && descB.Equals(descA))
{
descB = null;
}
string uniqueName;
if (nameA == null)
{
uniqueName = $"Title Screen:{teResourceGUID.Index(key):X}";
}
else
{
uniqueName = nameA + $":{teResourceGUID.Index(key):X}";
}
return(new MapInfo(uniqueName, key, nameA, nameB, descA, descB, subline, stateA, stateB,
map.m_map, map.m_baseMap, gamemodes));
}
public static ulong GetChunkKey(this STUMapHeader w, byte type)
{
return((GetChunkRoot(w) & ~0xFFFF00000000ul) | ((ulong)type << 32));
}
public MapHeader(STUMapHeader stu)
{
Init(stu);
}
public void SaveMaps(ICLIFlags toolFlags)
{
string basePath;
if (toolFlags is ExtractMapEnvFlags flags)
{
basePath = flags.OutputPath;
}
else
{
throw new Exception("no output path");
}
basePath = Path.Combine(basePath, "Environments");
if (!Directory.Exists(basePath))
{
Directory.CreateDirectory(basePath);
}
if (!flags.SkipMapEnvironmentLUT && File.Exists(Path.Combine(basePath, "SPILUT", "config.ocio")))
{
File.Delete(Path.Combine(basePath, "SPILUT", "config.ocio"));
}
HashSet <KeyValuePair <ulong, string> > done = new HashSet <KeyValuePair <ulong, string> >();
foreach (ulong metaKey in TrackedFiles[0x9F])
{
STUMapHeader map = GetInstance <STUMapHeader>(metaKey);
if (map == null)
{
continue;
}
MapInfo mapInfo = GetMap(metaKey);
mapInfo.Name = mapInfo.Name ?? "Title Screen";
mapInfo.NameB = mapInfo.NameB ?? mapInfo.Name;
ulong dataKey = map.m_map;
//if (teResourceGUID.Index(dataKey) != 0x7A4) continue;
using (Stream data = OpenFile(dataKey))
{
if (data == null)
{
continue;
}
using (BinaryReader dataReader = new BinaryReader(data))
{
teMap env = dataReader.Read <teMap>();
string fname = $"ow_map_{GetValidFilename($"{mapInfo.NameB}_{teResourceGUID.Index(mapInfo.MetadataGUID):X}")}";
//using (Stream lightingStream = OpenFile(env.BakedLighting)) {
// teLightingManifest lightingManifest = new teLightingManifest(lightingStream);
//}
if (!flags.SkipMapEnvironmentSound && done.Add(new KeyValuePair <ulong, string>(env.MapEnvironmentSound, mapInfo.Name)))
{
SaveSound(flags, basePath, Path.Combine("Sound", GetValidFilename($"{mapInfo.NameB}_{teResourceGUID.Index(mapInfo.MetadataGUID):X}")), env.MapEnvironmentSound);
}
if (!flags.SkipMapEnvironmentLUT && done.Add(new KeyValuePair <ulong, string>(env.LUT, mapInfo.Name)))
{
SaveTex(flags, basePath, "LUT", fname, env.LUT);
SaveLUT(flags, basePath, "SPILUT", fname, env.LUT, Path.Combine(basePath, "SPILUT", "config.ocio"), mapInfo);
}
if (!flags.SkipMapEnvironmentBlendCubemap && done.Add(new KeyValuePair <ulong, string>(env.BlendEnvironmentCubemap, mapInfo.Name)))
{
SaveTex(flags, basePath, "BlendCubemap", fname, env.BlendEnvironmentCubemap);
}
if (!flags.SkipMapEnvironmentGroundCubemap && done.Add(new KeyValuePair <ulong, string>(env.GroundEnvironmentCubemap, mapInfo.Name)))
{
SaveTex(flags, basePath, "GroundCubemap", fname, env.GroundEnvironmentCubemap);
}
if (!flags.SkipMapEnvironmentSkyCubemap && done.Add(new KeyValuePair <ulong, string>(env.SkyEnvironmentCubemap, mapInfo.Name)))
{
SaveTex(flags, basePath, "SkyCubemap", fname, env.SkyEnvironmentCubemap);
}
if (!flags.SkipMapEnvironmentSkybox && done.Add(new KeyValuePair <ulong, string>(env.SkyboxModel ^ env.SkyboxModelLook, mapInfo.Name)))
{
SaveMdl(flags, basePath, Path.Combine("Skybox", GetValidFilename($"{mapInfo.NameB}_{teResourceGUID.Index(mapInfo.MetadataGUID):X}")), env.SkyboxModel, env.SkyboxModelLook);
}
if (!flags.SkipMapEnvironmentEntity && done.Add(new KeyValuePair <ulong, string>(env.EntityDefinition, mapInfo.Name)))
{
SaveEntity(flags, basePath, Path.Combine("Entity", GetValidFilename($"{mapInfo.NameB}_{teResourceGUID.Index(mapInfo.MetadataGUID):X}")), env.EntityDefinition);
}
InfoLog("Saved Environment data for {0}", mapInfo.NameB);
}
}
}
}
protected static string GetMapName(ulong key)
{
STUMapHeader map = GetInstance <STUMapHeader>(key);
return(GetString(map.m_displayName));
}
public static ulong GetChunkKey(this STUMapHeader w, Enums.teMAP_PLACEABLE_TYPE type)
{
return((GetChunkRoot(w) & ~0xFFFF00000000ul) | ((ulong)type << 32));
}
public static teMapPlaceableData GetPlaceableData(STUMapHeader map, byte type)
{
return(GetPlaceableData(map, (Enums.teMAP_PLACEABLE_TYPE)type));
}
public static teMapPlaceableData GetPlaceableData(STUMapHeader map, Enums.teMAP_PLACEABLE_TYPE modelGroup)
{
using (Stream stream = OpenFile(map.GetChunkKey(modelGroup))) {
return(stream == null ? null : new teMapPlaceableData(stream, modelGroup));
}
}
