From d2bc9454ed3670cc67081edb306c9579c65e8459 Mon Sep 17 00:00:00 2001 From: Nick Blakely Date: Sat, 5 Sep 2020 16:47:00 -0700 Subject: [PATCH] Add binary tools assembly and FX decompiler. --- .gitignore | 1 + GPatch/CopyBinaries.bat | 10 +- GPatch/GPatch.nsi | 3 +- Giants.BinTools/Extensions.cs | 38 + Giants.BinTools/Giants.BinTools.csproj | 19 + .../Macro/DataDefinitionMacroLine.cs | 112 + Giants.BinTools/Macro/ElseMacroLine.cs | 7 + Giants.BinTools/Macro/EndIfMacroLine.cs | 7 + Giants.BinTools/Macro/GroupUseMacroLine.cs | 16 + Giants.BinTools/Macro/IfMacroLine.cs | 16 + Giants.BinTools/Macro/KnownMacroGroupNames.cs | 7 + .../Macro/KnownSymbolGroupNames.cs | 29 + Giants.BinTools/Macro/MacroDefinition.cs | 78 + Giants.BinTools/Macro/MacroDefinitionTable.cs | 108 + Giants.BinTools/Macro/MacroInstruction.cs | 18 + Giants.BinTools/Macro/MacroLine.cs | 10 + Giants.BinTools/Macro/MacroLineFactory.cs | 24 + .../Macro/MacroLineJsonConverter.cs | 47 + Giants.BinTools/Macro/MacroLineType.cs | 12 + Giants.BinTools/Symbol/SymbolTable.cs | 83 + .../Contracts/V1/AppVersion.cs | 10 +- .../Contracts/V1/PlayerInfo.cs | 12 +- .../Contracts/V1/ServerInfo.cs | 52 +- .../Contracts/V1/ServerInfoWithHostAddress.cs | 4 +- .../Giants.EffectCompiler.Tests.csproj | 20 + .../Integration/DecompileCompileTests.cs | 57 + .../TestResources/fx.bin | Bin 0 -> 149651 bytes .../Compiler/ContentEntry.cs | 8 + Giants.EffectCompiler/Compiler/FxCompiler.cs | 155 + .../Compiler/SerializedEffectData.cs | 13 + .../Decompiler/FxDecompiler.cs | 176 + Giants.EffectCompiler/Definitions.json | 7894 +++++++++++++++++ Giants.EffectCompiler/FxBinaryData.cs | 33 + Giants.EffectCompiler/FxMacroDefinition.cs | 14 + .../FxMacroDefinitionTable.cs | 161 + .../Giants.EffectCompiler.csproj | 37 + Giants.EffectCompiler/NLog.config | 12 + Giants.EffectCompiler/Program.cs | 49 + Giants.EffectCompiler/Utilities.cs | 49 + .../Controllers/ServersController.cs | 4 +- .../Controllers/VersionController.cs | 2 +- Giants.WebApi/Giants.WebApi.csproj | 1 + Giants.WebApi/Startup.cs | 4 +- GiantsTools.sln | 42 + 44 files changed, 9407 insertions(+), 47 deletions(-) create mode 100644 Giants.BinTools/Extensions.cs create mode 100644 Giants.BinTools/Giants.BinTools.csproj create mode 100644 Giants.BinTools/Macro/DataDefinitionMacroLine.cs create mode 100644 Giants.BinTools/Macro/ElseMacroLine.cs create mode 100644 Giants.BinTools/Macro/EndIfMacroLine.cs create mode 100644 Giants.BinTools/Macro/GroupUseMacroLine.cs create mode 100644 Giants.BinTools/Macro/IfMacroLine.cs create mode 100644 Giants.BinTools/Macro/KnownMacroGroupNames.cs create mode 100644 Giants.BinTools/Macro/KnownSymbolGroupNames.cs create mode 100644 Giants.BinTools/Macro/MacroDefinition.cs create mode 100644 Giants.BinTools/Macro/MacroDefinitionTable.cs create mode 100644 Giants.BinTools/Macro/MacroInstruction.cs create mode 100644 Giants.BinTools/Macro/MacroLine.cs create mode 100644 Giants.BinTools/Macro/MacroLineFactory.cs create mode 100644 Giants.BinTools/Macro/MacroLineJsonConverter.cs create mode 100644 Giants.BinTools/Macro/MacroLineType.cs create mode 100644 Giants.BinTools/Symbol/SymbolTable.cs create mode 100644 Giants.EffectCompiler.Tests/Giants.EffectCompiler.Tests.csproj create mode 100644 Giants.EffectCompiler.Tests/Integration/DecompileCompileTests.cs create mode 100644 Giants.EffectCompiler.Tests/TestResources/fx.bin create mode 100644 Giants.EffectCompiler/Compiler/ContentEntry.cs create mode 100644 Giants.EffectCompiler/Compiler/FxCompiler.cs create mode 100644 Giants.EffectCompiler/Compiler/SerializedEffectData.cs create mode 100644 Giants.EffectCompiler/Decompiler/FxDecompiler.cs create mode 100644 Giants.EffectCompiler/Definitions.json create mode 100644 Giants.EffectCompiler/FxBinaryData.cs create mode 100644 Giants.EffectCompiler/FxMacroDefinition.cs create mode 100644 Giants.EffectCompiler/FxMacroDefinitionTable.cs create mode 100644 Giants.EffectCompiler/Giants.EffectCompiler.csproj create mode 100644 Giants.EffectCompiler/NLog.config create mode 100644 Giants.EffectCompiler/Program.cs create mode 100644 Giants.EffectCompiler/Utilities.cs diff --git a/.gitignore b/.gitignore index 21f755d..82c2d45 100644 --- a/.gitignore +++ b/.gitignore @@ -14,6 +14,7 @@ profile.arm.json # User-specific files (MonoDevelop/Xamarin Studio) *.userprefs +launchSettings.json # Build results [Dd]ebug/ diff --git a/GPatch/CopyBinaries.bat b/GPatch/CopyBinaries.bat index 86d3d3f..9afbd4e 100644 --- a/GPatch/CopyBinaries.bat +++ b/GPatch/CopyBinaries.bat @@ -1,12 +1,18 @@ xcopy "%GIANTS_PATH%\gg_dx7r.dll" "Files\" /Y xcopy "%GIANTS_PATH%\gg_dx9r.dll" "Files\" /Y +xcopy "%GIANTS_PATH%\dedicated.exe" "Files\" /Y xcopy "%GIANTS_PATH%\Giants.exe" "Files\" /Y xcopy "%GIANTS_PATH%\GiantsMain.exe" "Files\" /Y xcopy "%GIANTS_PATH%\GiantsDedicated.exe" "Files\" /Y xcopy "%GIANTS_PATH%\gs_ds.dll" "Files\" /Y xcopy "%GIANTS_PATH%\Giants.WebApi.Clients.dll" "Files\" /Y xcopy "%GIANTS_PATH%\fmt.dll" "Files\" /Y -xcopy "%GIANTS_PATH%\BugTrap.dll" "Files\" /Y +xcopy "%GIANTS_PATH%\crashrpt_lang.ini" "Files\" /Y +xcopy "%GIANTS_PATH%\CrashRpt1403.dll" "Files\" /Y +xcopy "%GIANTS_PATH%\CrashSender1403.exe" "Files\" /Y +xcopy "%GIANTS_PATH%\dbghelp.dll" "Files\" /Y xcopy "%GIANTS_PATH%\cpprest_2_10.dll" "Files\" /Y xcopy "%GIANTS_PATH%\Newtonsoft.Json.dll" "Files\" /Y -xcopy "%GIANTS_PATH%\zlib1.dll" "Files\" /Y \ No newline at end of file +xcopy "%GIANTS_PATH%\zlib1.dll" "Files\" /Y + +pause \ No newline at end of file diff --git a/GPatch/GPatch.nsi b/GPatch/GPatch.nsi index 3f12d3c..d466c76 100644 --- a/GPatch/GPatch.nsi +++ b/GPatch/GPatch.nsi @@ -42,7 +42,7 @@ SetCompressor /SOLID lzma ; MUI end ------ Name "${PRODUCT_NAME} ${PRODUCT_VERSION}" -OutFile "Output\GPatch1_498_204_0.exe" +OutFile "Output\GPatch1_498_206_0.exe" InstallDir "$PROGRAMFILES\Giants\" InstallDirRegKey HKCU "SOFTWARE\PlanetMoon\Giants" "DestDir" ShowInstDetails hide @@ -77,6 +77,7 @@ Section Delete $INSTDIR\gg_dx8r.dll Delete $INSTDIR\gg_dx9r.dll Delete $INSTDIR\Giants.exe + Delete $INSTDIR\BugTrap.dll Delete $INSTDIR\GiantsMain.exe Delete $INSTDIR\*.vso Delete $INSTDIR\*.pso diff --git a/Giants.BinTools/Extensions.cs b/Giants.BinTools/Extensions.cs new file mode 100644 index 0000000..5e1267d --- /dev/null +++ b/Giants.BinTools/Extensions.cs @@ -0,0 +1,38 @@ +namespace Giants.BinTools +{ + using System.IO; + using System.Text; + + public static class Extensions + { + /// + /// Reads a null-terminated C-string from the binary reader. + /// + public static string ReadCString(this BinaryReader reader) + { + var stringBuilder = new StringBuilder(); + + while (true) + { + char c = reader.ReadChar(); + if (c == '\0') + { + break; + } + + stringBuilder.Append(c); + } + + return stringBuilder.ToString(); + } + + /// + /// Writes a null-terminated C-string to the binary writer. + /// + public static void WriteCString(this BinaryWriter writer, string value) + { + writer.Write(Encoding.UTF8.GetBytes(value)); + writer.Write('\0'); + } + } +} diff --git a/Giants.BinTools/Giants.BinTools.csproj b/Giants.BinTools/Giants.BinTools.csproj new file mode 100644 index 0000000..bcda015 --- /dev/null +++ b/Giants.BinTools/Giants.BinTools.csproj @@ -0,0 +1,19 @@ + + + + Library + netcoreapp3.1 + + + + + + + + + + PreserveNewest + + + + diff --git a/Giants.BinTools/Macro/DataDefinitionMacroLine.cs b/Giants.BinTools/Macro/DataDefinitionMacroLine.cs new file mode 100644 index 0000000..0ee1943 --- /dev/null +++ b/Giants.BinTools/Macro/DataDefinitionMacroLine.cs @@ -0,0 +1,112 @@ +namespace Giants.BinTools.Macro +{ + using System; + using System.IO; + using Giants.BinTools; + using Giants.BinTools.Symbol; + using Newtonsoft.Json; + + public class DataDefinitionMacroLine : MacroLine + { + public MacroLineType Type => MacroLineType.DataDefinition; + + [JsonProperty] + public string Instruction { get; private set; } + + [JsonProperty] + public string Constant { get; private set; } + + [JsonProperty] + public string ConstantName { get; private set; } + + [JsonProperty] + public string ArgumentPrefix { get; private set; } + + [JsonProperty] + public int ArgumentIndex { get; private set; } + + public DataDefinitionMacroLine(string instruction, string[] lineData, SymbolTable symbolTable) + { + this.Instruction = instruction; + + string data = lineData[1]; + + int argIndexRef = data.IndexOf("\\"); + if (argIndexRef > 0) + { + this.ArgumentPrefix = data[0..argIndexRef]; + data = data[argIndexRef..]; + } + + if (data.StartsWith("\\")) + { + string index = data[1..]; + if (index != "#") + { + this.ArgumentIndex = Convert.ToInt32(data[1..]); + } + } + else + { + string groupName = KnownSymbolGroupNames.GetGroupName(data); + if (groupName != null) + { + this.ConstantName = data; + if (symbolTable.TryGetSymbolFromName(groupName, data, out int symbolValue)) + { + this.Constant = symbolValue.ToString(); + } + } + + if (this.Constant == null) + { + this.Constant = data; + } + } + } + + internal DataDefinitionMacroLine() { } + + public string Deserialize(BinaryReader reader, SymbolTable symbolTable) + { + string value = this.Instruction switch + { + MacroInstruction.DefByte => reader.ReadByte().ToString(), + MacroInstruction.DefFloat => reader.ReadSingle().ToString(), + MacroInstruction.DefLong => reader.ReadInt32().ToString(), + MacroInstruction.Name0cs => reader.ReadCString(), + _ => throw new NotSupportedException() + }; + + if (!string.IsNullOrEmpty(this.ArgumentPrefix)) + { + if (int.TryParse(value, out int intValue) && symbolTable.TryGetSymbolFromId(this.ArgumentPrefix, intValue, out string symbolName)) + { + return symbolName[this.ArgumentPrefix.Length..]; + } + } + + return value; + } + + public void Serialize(string token, SymbolTable symbolTable, BinaryWriter binaryWriter) + { + if (!string.IsNullOrEmpty(this.ArgumentPrefix)) + { + if (symbolTable.TryGetSymbolFromName(this.ArgumentPrefix, this.ArgumentPrefix + token, out int symbolValue)) + { + token = symbolValue.ToString(); + } + } + + switch (this.Instruction) + { + case MacroInstruction.DefByte: binaryWriter.Write((byte)Convert.ChangeType(token, typeof(byte))); break; + case MacroInstruction.DefFloat: binaryWriter.Write((float)Convert.ChangeType(token, typeof(float))); break; + case MacroInstruction.DefLong: binaryWriter.Write((int)Convert.ChangeType(token, typeof(int))); break; + case MacroInstruction.Name0cs: binaryWriter.WriteCString(token); break; + default: throw new NotSupportedException(); + } + } + } +} diff --git a/Giants.BinTools/Macro/ElseMacroLine.cs b/Giants.BinTools/Macro/ElseMacroLine.cs new file mode 100644 index 0000000..a0e6e6f --- /dev/null +++ b/Giants.BinTools/Macro/ElseMacroLine.cs @@ -0,0 +1,7 @@ +namespace Giants.BinTools.Macro +{ + public class ElseMacroLine : MacroLine + { + public MacroLineType Type => MacroLineType.Else; + } +} diff --git a/Giants.BinTools/Macro/EndIfMacroLine.cs b/Giants.BinTools/Macro/EndIfMacroLine.cs new file mode 100644 index 0000000..75f4547 --- /dev/null +++ b/Giants.BinTools/Macro/EndIfMacroLine.cs @@ -0,0 +1,7 @@ +namespace Giants.BinTools.Macro +{ + public class EndIfMacroLine : MacroLine + { + public MacroLineType Type => MacroLineType.EndIf; + } +} diff --git a/Giants.BinTools/Macro/GroupUseMacroLine.cs b/Giants.BinTools/Macro/GroupUseMacroLine.cs new file mode 100644 index 0000000..28ca712 --- /dev/null +++ b/Giants.BinTools/Macro/GroupUseMacroLine.cs @@ -0,0 +1,16 @@ +namespace Giants.BinTools.Macro +{ + public class GroupUseMacroLine : MacroLine + { + public MacroLineType Type => MacroLineType.GroupUse; + + public string GroupName { get; set; } + + public GroupUseMacroLine(string[] tokens) + { + this.GroupName = tokens[1]; + } + + internal GroupUseMacroLine() { } + } +} diff --git a/Giants.BinTools/Macro/IfMacroLine.cs b/Giants.BinTools/Macro/IfMacroLine.cs new file mode 100644 index 0000000..05fc977 --- /dev/null +++ b/Giants.BinTools/Macro/IfMacroLine.cs @@ -0,0 +1,16 @@ +namespace Giants.BinTools.Macro +{ + public class IfMacroLine : MacroLine + { + public MacroLineType Type => MacroLineType.If; + + public string Condition { get; } + + public IfMacroLine(string[] tokens) + { + this.Condition = string.Join(" ", tokens[1..]); + } + + internal IfMacroLine() { } + } +} diff --git a/Giants.BinTools/Macro/KnownMacroGroupNames.cs b/Giants.BinTools/Macro/KnownMacroGroupNames.cs new file mode 100644 index 0000000..57f01ff --- /dev/null +++ b/Giants.BinTools/Macro/KnownMacroGroupNames.cs @@ -0,0 +1,7 @@ +namespace Giants.BinTools.Macro +{ + public static class KnownMacroGroupNames + { + public const string FxDefGroup = "fxdefgroup"; + } +} diff --git a/Giants.BinTools/Macro/KnownSymbolGroupNames.cs b/Giants.BinTools/Macro/KnownSymbolGroupNames.cs new file mode 100644 index 0000000..d0f3e24 --- /dev/null +++ b/Giants.BinTools/Macro/KnownSymbolGroupNames.cs @@ -0,0 +1,29 @@ +namespace Giants.BinTools.Macro +{ + using System; + using System.Collections.Generic; + + public static class KnownSymbolGroupNames + { + public const string Sfx = "sfx"; + public const string Fx = "Fx"; + public const string Object = "ObjObj"; + public const string ObjectData = "ObjData"; + public const string ObjectGroup = "ObjGroup"; + + public static readonly IList Names = new[] { Sfx, Fx, Object, ObjectData, ObjectGroup }; + + public static string GetGroupName(string str) + { + foreach (string groupName in Names) + { + if (str.StartsWith(groupName, StringComparison.OrdinalIgnoreCase)) + { + return groupName; + } + } + + return null; + } + } +} diff --git a/Giants.BinTools/Macro/MacroDefinition.cs b/Giants.BinTools/Macro/MacroDefinition.cs new file mode 100644 index 0000000..bcb8ad5 --- /dev/null +++ b/Giants.BinTools/Macro/MacroDefinition.cs @@ -0,0 +1,78 @@ +namespace Giants.BinTools.Macro +{ + using System; + using System.Collections.Generic; + using System.IO; + using System.Linq; + using Giants.BinTools.Symbol; + using NLog; + + public class MacroDefinition + { + private static readonly Logger logger = LogManager.GetLogger(nameof(MacroDefinition)); + + private static readonly string[] SplitCharacters = new string[] { " ", "\t" }; + + public IDictionary> Groups { get; } + + public string Name { get; set; } + + public MacroDefinition(string name, IDictionary> groups = null) + { + this.Name = name; + this.Groups = groups ?? new Dictionary>(); + } + + public void Read(StreamReader reader, SymbolTable symbolTable) + { + string activeGroup = string.Empty; + + while (true) + { + string line = reader.ReadLine(); + if (line == null) + { + throw new InvalidOperationException($"Unexpected end of macro definition in '{this.Name}'"); + } + + line = line.Trim(); + if (line.StartsWith(";") || string.IsNullOrWhiteSpace(line)) + { + continue; + } + + if (line.StartsWith(MacroInstruction.MacroDefinitionEnd)) + { + break; + } + + string[] opcodeData = line.Split(SplitCharacters, StringSplitOptions.RemoveEmptyEntries); + + var macroLine = MacroLineFactory.Read(opcodeData, symbolTable); + if (macroLine == null) + { + continue; + } + + if (!this.Groups.Any() && !(macroLine is GroupUseMacroLine)) + { + logger.Warn($"Warning: expected 'groupuse' for macro {this.Name}; this may be a bug"); + + // Try to recover + this.Groups.TryAdd("-MISSING-", new List()); + activeGroup = "-MISSING-"; + } + + if (macroLine is GroupUseMacroLine groupUseMacroLine) + { + this.Groups[groupUseMacroLine.GroupName] = new List(); + activeGroup = groupUseMacroLine.GroupName; + } + else + { + this.Groups[activeGroup].Add(macroLine); + } + } + } + } +} diff --git a/Giants.BinTools/Macro/MacroDefinitionTable.cs b/Giants.BinTools/Macro/MacroDefinitionTable.cs new file mode 100644 index 0000000..d3b2bb5 --- /dev/null +++ b/Giants.BinTools/Macro/MacroDefinitionTable.cs @@ -0,0 +1,108 @@ +namespace Giants.BinTools.Macro +{ + using System; + using System.Collections.Generic; + using System.Globalization; + using System.IO; + using System.Linq; + using Giants.BinTools.Symbol; + using NLog; + + public class MacroDefinitionTable + { + private static readonly Logger logger = LogManager.GetLogger(nameof(MacroDefinition)); + + private static readonly string[] SplitCharacters = new string[] { " ", "\t" }; + + private readonly HashSet includedFiles = new HashSet(); + + public SymbolTable SymbolTable { get; } = new SymbolTable(); + + public IList MacroDefinitions { get; } = new List(); + + public static MacroDefinitionTable GenerateFromLegacyBuildSystem(string bldFilePath) + { + var table = new MacroDefinitionTable(); + table.ProcessFile(bldFilePath); + + return table; + } + + private void ProcessFile(string bldFilePath) + { + using FileStream stream = File.OpenRead(bldFilePath); + using StreamReader streamReader = new StreamReader(stream); + + string currentLine; + do + { + currentLine = streamReader.ReadLine(); + if (currentLine == null) + { + break; + } + + currentLine = currentLine.Trim(); + string[] tokens = currentLine.Split(SplitCharacters, StringSplitOptions.RemoveEmptyEntries); + + if (currentLine.StartsWith(";") || !tokens.Any()) + { + continue; + } + else if (tokens[0].Equals(MacroInstruction.MacroDefinitionStart, StringComparison.OrdinalIgnoreCase)) + { + MacroDefinition macroDefinition = this.ReadDefinition(currentLine, streamReader); + this.MacroDefinitions.Add(macroDefinition); + } + else if (tokens[0].Equals(MacroInstruction.IncludeFile, StringComparison.OrdinalIgnoreCase)) + { + string includeFile = tokens[1]; + if (this.includedFiles.Contains(includeFile)) + { + continue; + } + + string directory = Directory.GetParent(bldFilePath).FullName; + string includeFilePath = Path.Combine(directory, includeFile); + if (string.IsNullOrEmpty(Path.GetExtension(includeFilePath))) + { + includeFilePath = includeFilePath + ".bld"; + } + + this.ProcessFile(includeFilePath); + } + else if (tokens[0].Equals(MacroInstruction.Define, StringComparison.OrdinalIgnoreCase)) + { + if (int.TryParse(tokens[2], NumberStyles.Number, CultureInfo.InvariantCulture, out int symbolValue)) + { + string groupName = KnownSymbolGroupNames.GetGroupName(tokens[1]); + if (groupName != null) + { + this.SymbolTable.AddSymbol(groupName, tokens[1], symbolValue); + } + } + else + { + logger.Warn($"Failed to parse symbol '{tokens[2]}'; only integer constants are supported"); + } + } + + } while (currentLine != null); + } + + MacroDefinition ReadDefinition(string line, StreamReader reader) + { + string[] opcodeData = line.Split(SplitCharacters, StringSplitOptions.RemoveEmptyEntries); + + // Save definition name + string macroName = opcodeData[1]; + + var macroDefinition = new MacroDefinition(macroName); + macroDefinition.Read(reader, this.SymbolTable); + + return macroDefinition; + } + + private MacroDefinitionTable() { } + } +} diff --git a/Giants.BinTools/Macro/MacroInstruction.cs b/Giants.BinTools/Macro/MacroInstruction.cs new file mode 100644 index 0000000..39c764e --- /dev/null +++ b/Giants.BinTools/Macro/MacroInstruction.cs @@ -0,0 +1,18 @@ +namespace Giants.BinTools.Macro +{ + public static class MacroInstruction + { + public const string IncludeFile = "include"; + public const string MacroDefinitionStart = "macro"; + public const string MacroDefinitionEnd = "macend"; + public const string Define = "#define"; + public const string DefByte = "db"; + public const string DefLong = "dl"; + public const string DefFloat = "df"; + public const string Name0cs = "name0cs"; + public const string GroupUse = "groupuse"; + public const string If = "if"; + public const string Else = "else"; + public const string EndIf = "endif"; + } +} diff --git a/Giants.BinTools/Macro/MacroLine.cs b/Giants.BinTools/Macro/MacroLine.cs new file mode 100644 index 0000000..cb5fd8d --- /dev/null +++ b/Giants.BinTools/Macro/MacroLine.cs @@ -0,0 +1,10 @@ +using Newtonsoft.Json; + +namespace Giants.BinTools.Macro +{ + [JsonConverter(typeof(MacroLineJsonConverter))] + public interface MacroLine + { + public MacroLineType Type { get; } + } +} diff --git a/Giants.BinTools/Macro/MacroLineFactory.cs b/Giants.BinTools/Macro/MacroLineFactory.cs new file mode 100644 index 0000000..1b4d754 --- /dev/null +++ b/Giants.BinTools/Macro/MacroLineFactory.cs @@ -0,0 +1,24 @@ +namespace Giants.BinTools.Macro +{ + using Giants.BinTools.Symbol; + + public static class MacroLineFactory + { + public static MacroLine Read(string[] tokens, SymbolTable symbolTable) + { + string instruction = tokens[0].ToLowerInvariant().Trim(); + return instruction switch + { + MacroInstruction.GroupUse => new GroupUseMacroLine(tokens), + MacroInstruction.DefByte => new DataDefinitionMacroLine(instruction, tokens, symbolTable), + MacroInstruction.DefFloat => new DataDefinitionMacroLine(instruction, tokens, symbolTable), + MacroInstruction.DefLong => new DataDefinitionMacroLine(instruction, tokens, symbolTable), + MacroInstruction.Name0cs => new DataDefinitionMacroLine(instruction, tokens, symbolTable), + MacroInstruction.If => new IfMacroLine(tokens), + MacroInstruction.Else => new ElseMacroLine(), + MacroInstruction.EndIf => new EndIfMacroLine(), + _ => null, + }; + } + } +} diff --git a/Giants.BinTools/Macro/MacroLineJsonConverter.cs b/Giants.BinTools/Macro/MacroLineJsonConverter.cs new file mode 100644 index 0000000..22cc8ee --- /dev/null +++ b/Giants.BinTools/Macro/MacroLineJsonConverter.cs @@ -0,0 +1,47 @@ +namespace Giants.BinTools.Macro +{ + using System; + using Newtonsoft.Json; + using Newtonsoft.Json.Converters; + using Newtonsoft.Json.Linq; + + public class MacroLineJsonConverter : CustomCreationConverter + { + private MacroLineType type; + public override bool CanConvert(Type objectType) + { + return (objectType == typeof(MacroLine)); + } + + public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) + { + var jObject = JObject.ReadFrom(reader); + this.type = jObject["Type"].ToObject(); + return base.ReadJson(jObject.CreateReader(), objectType, existingValue, serializer); + } + + public override bool CanWrite + { + get { return false; } + } + + public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) + { + throw new NotImplementedException(); + } + + public override MacroLine Create(Type objectType) + { + switch (this.type) + { + case MacroLineType.DataDefinition: return new DataDefinitionMacroLine(); + case MacroLineType.Else: return new ElseMacroLine(); + case MacroLineType.EndIf: return new EndIfMacroLine(); + case MacroLineType.GroupUse: return new GroupUseMacroLine(); + case MacroLineType.If: return new IfMacroLine(); + } + + throw new NotSupportedException(); + } + } +} diff --git a/Giants.BinTools/Macro/MacroLineType.cs b/Giants.BinTools/Macro/MacroLineType.cs new file mode 100644 index 0000000..12e44a1 --- /dev/null +++ b/Giants.BinTools/Macro/MacroLineType.cs @@ -0,0 +1,12 @@ +namespace Giants.BinTools.Macro +{ + public enum MacroLineType + { + None = 0, + DataDefinition, + If, + Else, + EndIf, + GroupUse + } +} diff --git a/Giants.BinTools/Symbol/SymbolTable.cs b/Giants.BinTools/Symbol/SymbolTable.cs new file mode 100644 index 0000000..ac33d36 --- /dev/null +++ b/Giants.BinTools/Symbol/SymbolTable.cs @@ -0,0 +1,83 @@ +namespace Giants.BinTools.Symbol +{ + using System; + using System.Collections.Generic; + using System.Runtime.Serialization; + using Newtonsoft.Json; + + public class SymbolTable + { + private static readonly HashSet ExcludedSymbols = new HashSet() { "FxBinVersion", "SfxVersionOld", "SfxVersion1", "SfxVersion2" }; + + [JsonProperty(nameof(symbols))] + private IDictionary> symbols = new Dictionary>(StringComparer.OrdinalIgnoreCase); + + private IDictionary> reverseSymbolLookup = new Dictionary>(StringComparer.OrdinalIgnoreCase); + + [OnDeserialized] + internal void OnDeserialized(StreamingContext context) + { + foreach (var symbolGroup in this.symbols) + { + this.reverseSymbolLookup.Add(symbolGroup.Key, new Dictionary()); + foreach (var symbol in this.symbols[symbolGroup.Key]) + { + this.reverseSymbolLookup[symbolGroup.Key].Add(symbol.Value, symbol.Key); + } + } + } + + public void AddSymbol(string symbolGroup, string symbolName, int symbolValue) + { + if (ExcludedSymbols.Contains(symbolName)) + { + return; + } + + if (!this.symbols.ContainsKey(symbolGroup)) + { + this.symbols.Add(symbolGroup, new CaseInsensitiveDictionary()); + } + + if (!this.reverseSymbolLookup.ContainsKey(symbolGroup)) + { + this.reverseSymbolLookup.Add(symbolGroup, new Dictionary()); + } + + this.symbols[symbolGroup].Add(symbolName, symbolValue); + this.reverseSymbolLookup[symbolGroup].Add(symbolValue, symbolName); + } + + public bool ContainsKey(string symbolGroup, string key) + { + if (!string.IsNullOrEmpty(symbolGroup) && !string.IsNullOrEmpty(key)) + { + return this.symbols.ContainsKey(symbolGroup) + && this.symbols[symbolGroup].ContainsKey(key); + } + + return false; + } + + public bool TryGetSymbolFromName(string symbolGroup, string symbolName, out int symbolValue) + { + return this.symbols[symbolGroup].TryGetValue(symbolName, out symbolValue); + } + + public bool TryGetSymbolFromId(string symbolGroup, int symbolValue, out string symbolName) + { + return this.reverseSymbolLookup[symbolGroup].TryGetValue(symbolValue, out symbolName); + } + + public IDictionary GetSymbolGroup(string symbolGroup) + { + return this.symbols[symbolGroup]; + } + + private class CaseInsensitiveDictionary : Dictionary + { + public CaseInsensitiveDictionary() + : base(StringComparer.OrdinalIgnoreCase) { } + } + } +} diff --git a/Giants.DataContract/Contracts/V1/AppVersion.cs b/Giants.DataContract/Contracts/V1/AppVersion.cs index 5bcf9c8..f4ab976 100644 --- a/Giants.DataContract/Contracts/V1/AppVersion.cs +++ b/Giants.DataContract/Contracts/V1/AppVersion.cs @@ -20,15 +20,15 @@ public override bool Equals(object obj) { return obj is AppVersion info && - Build == info.Build && - Major == info.Major && - Minor == info.Minor && - Revision == info.Revision; + this.Build == info.Build && + this.Major == info.Major && + this.Minor == info.Minor && + this.Revision == info.Revision; } public override int GetHashCode() { - return HashCode.Combine(Build, Major, Minor, Revision); + return HashCode.Combine(this.Build, this.Major, this.Minor, this.Revision); } public Version ToVersion() diff --git a/Giants.DataContract/Contracts/V1/PlayerInfo.cs b/Giants.DataContract/Contracts/V1/PlayerInfo.cs index f804f64..1672140 100644 --- a/Giants.DataContract/Contracts/V1/PlayerInfo.cs +++ b/Giants.DataContract/Contracts/V1/PlayerInfo.cs @@ -23,16 +23,16 @@ namespace Giants.DataContract.V1 public override bool Equals(object obj) { return obj is PlayerInfo info && - Index == info.Index && - Name == info.Name && - Frags == info.Frags && - Deaths == info.Deaths && - TeamName == info.TeamName; + this.Index == info.Index && + this.Name == info.Name && + this.Frags == info.Frags && + this.Deaths == info.Deaths && + this.TeamName == info.TeamName; } public override int GetHashCode() { - return HashCode.Combine(Index, Name, Frags, Deaths, TeamName); + return HashCode.Combine(this.Index, this.Name, this.Frags, this.Deaths, this.TeamName); } } } diff --git a/Giants.DataContract/Contracts/V1/ServerInfo.cs b/Giants.DataContract/Contracts/V1/ServerInfo.cs index 31d45a9..d2a9528 100644 --- a/Giants.DataContract/Contracts/V1/ServerInfo.cs +++ b/Giants.DataContract/Contracts/V1/ServerInfo.cs @@ -54,37 +54,37 @@ public override bool Equals(object obj) { return obj is ServerInfo info && - GameName == info.GameName && - EqualityComparer.Default.Equals(Version, info.Version) && - SessionName == info.SessionName && - Port == info.Port && - MapName == info.MapName && - GameType == info.GameType && - NumPlayers == info.NumPlayers && - GameState == info.GameState && - TimeLimit == info.TimeLimit && - FragLimit == info.FragLimit && - TeamFragLimit == info.TeamFragLimit && - FirstBaseComplete == info.FirstBaseComplete && - PlayerInfo.SequenceEqual(info.PlayerInfo); + this.GameName == info.GameName && + EqualityComparer.Default.Equals(this.Version, info.Version) && + this.SessionName == info.SessionName && + this.Port == info.Port && + this.MapName == info.MapName && + this.GameType == info.GameType && + this.NumPlayers == info.NumPlayers && + this.GameState == info.GameState && + this.TimeLimit == info.TimeLimit && + this.FragLimit == info.FragLimit && + this.TeamFragLimit == info.TeamFragLimit && + this.FirstBaseComplete == info.FirstBaseComplete && + this.PlayerInfo.SequenceEqual(info.PlayerInfo); } public override int GetHashCode() { HashCode hash = new HashCode(); - hash.Add(GameName); - hash.Add(Version); - hash.Add(SessionName); - hash.Add(Port); - hash.Add(MapName); - hash.Add(GameType); - hash.Add(NumPlayers); - hash.Add(GameState); - hash.Add(TimeLimit); - hash.Add(FragLimit); - hash.Add(TeamFragLimit); - hash.Add(FirstBaseComplete); - hash.Add(PlayerInfo); + hash.Add(this.GameName); + hash.Add(this.Version); + hash.Add(this.SessionName); + hash.Add(this.Port); + hash.Add(this.MapName); + hash.Add(this.GameType); + hash.Add(this.NumPlayers); + hash.Add(this.GameState); + hash.Add(this.TimeLimit); + hash.Add(this.FragLimit); + hash.Add(this.TeamFragLimit); + hash.Add(this.FirstBaseComplete); + hash.Add(this.PlayerInfo); return hash.ToHashCode(); } } diff --git a/Giants.DataContract/Contracts/V1/ServerInfoWithHostAddress.cs b/Giants.DataContract/Contracts/V1/ServerInfoWithHostAddress.cs index 4e4707a..dfb89cc 100644 --- a/Giants.DataContract/Contracts/V1/ServerInfoWithHostAddress.cs +++ b/Giants.DataContract/Contracts/V1/ServerInfoWithHostAddress.cs @@ -12,14 +12,14 @@ { return obj is ServerInfoWithHostAddress address && base.Equals(obj) && - HostIpAddress == address.HostIpAddress; + this.HostIpAddress == address.HostIpAddress; } public override int GetHashCode() { HashCode hash = new HashCode(); hash.Add(base.GetHashCode()); - hash.Add(HostIpAddress); + hash.Add(this.HostIpAddress); return hash.ToHashCode(); } } diff --git a/Giants.EffectCompiler.Tests/Giants.EffectCompiler.Tests.csproj b/Giants.EffectCompiler.Tests/Giants.EffectCompiler.Tests.csproj new file mode 100644 index 0000000..86d94a6 --- /dev/null +++ b/Giants.EffectCompiler.Tests/Giants.EffectCompiler.Tests.csproj @@ -0,0 +1,20 @@ + + + + netcoreapp3.1 + + false + + + + + + + + + + + + + + diff --git a/Giants.EffectCompiler.Tests/Integration/DecompileCompileTests.cs b/Giants.EffectCompiler.Tests/Integration/DecompileCompileTests.cs new file mode 100644 index 0000000..790630e --- /dev/null +++ b/Giants.EffectCompiler.Tests/Integration/DecompileCompileTests.cs @@ -0,0 +1,57 @@ +namespace Giants.EffectCompiler.Tests.Integration +{ + using System; + using System.IO; + using Microsoft.VisualStudio.TestTools.UnitTesting; + + [TestClass] + public class DecompileCompileTests + { + private const string ProjectDirectoryPath = @"..\..\..\"; + + [TestMethod] + public void TestDecompileCompile() + { + // Verify round-trip of compiled file + + Guid testIdentifier = Guid.NewGuid(); + string textOutputPath = @$"Temp\fx_{testIdentifier}.txt"; + string binaryOutputPath = @$"Temp\fx_{testIdentifier}.bin"; + + try + { + var definitionTable = Utilities.LoadDefinitions(); + var fxDecompiler = new FxDecompiler(definitionTable); + fxDecompiler.Decompile( + Path.Combine(ProjectDirectoryPath, @"TestResources\fx.bin"), + Path.Combine(ProjectDirectoryPath, textOutputPath)); + + var fxCompiler = new FxCompiler(definitionTable); + fxCompiler.Compile( + Path.Combine(ProjectDirectoryPath, textOutputPath), + Path.Combine(ProjectDirectoryPath, binaryOutputPath)); + + using var originalFile = new BinaryReader(File.Open(Path.Combine(ProjectDirectoryPath, @"TestResources\fx.bin"), FileMode.Open)); + using var recompiledFile = new BinaryReader(File.Open(Path.Combine(ProjectDirectoryPath, binaryOutputPath), FileMode.Open)); + + if (originalFile.BaseStream.Length != recompiledFile.BaseStream.Length) + { + throw new InvalidOperationException("File sizes do not match."); + } + + while (originalFile.BaseStream.Position != originalFile.BaseStream.Length) + { + byte b1 = originalFile.ReadByte(); + byte b2 = recompiledFile.ReadByte(); + + Assert.AreEqual(b1, b2); + } + } + finally + { + File.Delete(Path.Combine(ProjectDirectoryPath, textOutputPath)); + File.Delete(Path.Combine(ProjectDirectoryPath, binaryOutputPath)); + } + } + } +} diff --git a/Giants.EffectCompiler.Tests/TestResources/fx.bin b/Giants.EffectCompiler.Tests/TestResources/fx.bin new file mode 100644 index 0000000000000000000000000000000000000000..dbf15e9e42a5a49e446e4895a40274632b5ee5ce GIT binary patch literal 149651 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 tpZNs4gh + /// Effect binary compiler. + /// + public class FxCompiler + { + private static readonly Logger logger = LogManager.GetLogger(nameof(FxCompiler)); + + private FxMacroDefinitionTable macroDefinitionTable; + private int doneOpcode; + + /// + /// Initializes a new instance of the class. + /// + /// The table of macro and symbol definitions. + public FxCompiler(FxMacroDefinitionTable macroDefinitionTable) + { + this.macroDefinitionTable = macroDefinitionTable; + } + + /// + /// Compiles a textual effect file to the specified output path. + /// + /// The path to the effect file. + /// The path to write to. + public void Compile( + string inputPath, + string outputPath) + { + if (!File.Exists(inputPath)) + { + throw new InvalidOperationException($"The input file {inputPath} does not exist."); + } + + // Get constants for known symbols + this.doneOpcode = Utilities.GetFxSymbolValue(this.macroDefinitionTable.SymbolTable, "FxDone"); + + using var streamReader = new StreamReader(inputPath); + SerializedEffectData serializedEffectData = this.SerializeEffectData(streamReader); + + using var fileStream = new FileStream(outputPath, FileMode.Create); + using var binaryWriter = new BinaryWriter(fileStream); + + this.WriteHeader(binaryWriter, serializedEffectData); + this.WriteTableOfContents(binaryWriter, serializedEffectData); + this.WriteEffectData(binaryWriter, serializedEffectData); + } + + private void WriteEffectData(BinaryWriter binaryWriter, SerializedEffectData serializedEffectData) + { + binaryWriter.Write(serializedEffectData.Data); + } + + private void WriteTableOfContents(BinaryWriter binaryWriter, SerializedEffectData serializedEffectData) + { + foreach (var entry in serializedEffectData.TableOfContents) + { + binaryWriter.Write(Encoding.UTF8.GetBytes(entry.Name)); + binaryWriter.Write('\0'); + binaryWriter.Write(checked(entry.Offset + serializedEffectData.TableOfContentsSize)); + } + } + + private void WriteHeader(BinaryWriter binaryWriter, SerializedEffectData serializedEffectData) + { + binaryWriter.Write(FxBinaryData.CurrentVersion); + binaryWriter.Write(checked(serializedEffectData.Data.Length + serializedEffectData.TableOfContentsSize)); + binaryWriter.Write(serializedEffectData.TableOfContents.Count); + } + + private void SerializeEffect(string[] tokens, StreamReader reader, BinaryWriter binaryWriter) + { + while (!reader.EndOfStream) + { + tokens = reader.ReadLine().Split(Utilities.SplitCharacters, StringSplitOptions.RemoveEmptyEntries); + + string macroName = tokens[0]; + if (macroName == "fxdone") + { + binaryWriter.Write((byte)this.doneOpcode); + break; + } + + FxMacroDefinition macroDefinition = this.macroDefinitionTable.MacroDefinitions + .Values + .FirstOrDefault(x => x.Name.Equals(macroName, StringComparison.OrdinalIgnoreCase) && x.FxDefGroup.Count() == tokens[1..].Length); + + binaryWriter.Write((byte)macroDefinition.Opcode); + + if (macroDefinition == null) + { + throw new InvalidOperationException("Unknown macro '{macroName}'"); + } + + var parameters = new List(); + int parameterIndex = 1; + foreach (var line in macroDefinition.FxDefGroup) + { + if (line is DataDefinitionMacroLine dataDefinitionMacroLine) + { + dataDefinitionMacroLine.Serialize(tokens[parameterIndex++], this.macroDefinitionTable.SymbolTable, binaryWriter); + } + } + } + } + + private SerializedEffectData SerializeEffectData(StreamReader streamReader) + { + using var memoryStream = new MemoryStream(); + using var binaryWriter = new BinaryWriter(memoryStream); + + var tableOfContents = new List(); + int tableOfContentsSize = 0; // Keep running total of the final (serialized) size of the TOC + + while (!streamReader.EndOfStream) + { + string[] tokens = streamReader.ReadLine().Split(Utilities.SplitCharacters, StringSplitOptions.RemoveEmptyEntries); + if (!tokens.Any()) + { + continue; + } + + if (tokens[0] == "fxdef") + { + var contentEntry = new ContentEntry() + { + Name = tokens[1], + Offset = checked((int)binaryWriter.BaseStream.Position) + }; + + tableOfContentsSize += contentEntry.Name.Length + 1 + sizeof(int); + tableOfContents.Add(contentEntry); + + this.SerializeEffect(tokens, streamReader, binaryWriter); + } + } + + return new SerializedEffectData + { + Data = memoryStream.ToArray(), + TableOfContents = tableOfContents, + TableOfContentsSize = tableOfContentsSize, + }; + } + } +} diff --git a/Giants.EffectCompiler/Compiler/SerializedEffectData.cs b/Giants.EffectCompiler/Compiler/SerializedEffectData.cs new file mode 100644 index 0000000..8d6f4a8 --- /dev/null +++ b/Giants.EffectCompiler/Compiler/SerializedEffectData.cs @@ -0,0 +1,13 @@ +namespace Giants.EffectCompiler +{ + using System.Collections.Generic; + + public class SerializedEffectData + { + public byte[] Data { get; set; } + + public int TableOfContentsSize { get; set; } + + public IList TableOfContents { get; set; } = new List(); + } +} diff --git a/Giants.EffectCompiler/Decompiler/FxDecompiler.cs b/Giants.EffectCompiler/Decompiler/FxDecompiler.cs new file mode 100644 index 0000000..a6f057a --- /dev/null +++ b/Giants.EffectCompiler/Decompiler/FxDecompiler.cs @@ -0,0 +1,176 @@ +namespace Giants.EffectCompiler +{ + using System; + using System.CodeDom.Compiler; + using System.Collections.Generic; + using System.IO; + using System.Text; + using Giants.BinTools; + using Giants.BinTools.Macro; + using NLog; + + /// + /// Effect binary decompiler. + /// + public class FxDecompiler + { + private static readonly Logger logger = LogManager.GetLogger(nameof(FxDecompiler)); + + private readonly Dictionary tableOfContents = new Dictionary(); + + private FxBinaryData binaryData; + private FxMacroDefinitionTable macroDefinitionTable; + private int doneOpcode; + private int pushObjOpcode; + private int popObjOpcode; + + /// + /// Initializes a new instance of the class. + /// + /// The table of macro and symbol definitions. + public FxDecompiler(FxMacroDefinitionTable macroDefinitionTable) + { + this.macroDefinitionTable = macroDefinitionTable; + } + + /// + /// Decompiles an effect binary file to the specified output path. + /// + /// The path to the effect binary file. + /// The path to write to. + public void Decompile( + string inputPath, + string outputPath) + + { + if (!File.Exists(inputPath)) + { + throw new InvalidOperationException($"The input file {inputPath} does not exist."); + } + + this.ReadBinaryData(inputPath); + + using var memoryStream = new MemoryStream(this.binaryData.Data); + using var binaryReader = new BinaryReader(memoryStream); + using var streamWriter = new StreamWriter(outputPath, false); + using var textWriter = new IndentedTextWriter(streamWriter); + + this.BuildTableOfContents(binaryReader); + + // Get constants for known symbols + this.doneOpcode = Utilities.GetFxSymbolValue(this.macroDefinitionTable.SymbolTable, "FxDone"); + this.pushObjOpcode = Utilities.GetFxSymbolValue(this.macroDefinitionTable.SymbolTable, "FxPushObj"); + this.popObjOpcode = Utilities.GetFxSymbolValue(this.macroDefinitionTable.SymbolTable, "FxPopObj"); + + this.ProcessEffects(binaryReader, textWriter); + } + + private void ReadBinaryData(string path) + { + using var fileStream = File.OpenRead(path); + this.binaryData = new FxBinaryData(fileStream); + } + + private void BuildTableOfContents(BinaryReader binaryReader) + { + for (int i = 0; i < this.binaryData.EffectCount; i++) + { + string fxName = binaryReader.ReadCString(); + int offset = binaryReader.ReadInt32(); + + if (this.tableOfContents.ContainsKey(fxName)) + { + logger.Warn($"TOC already contains fx '{fxName}'; this may be a bug"); + continue; + } + + this.tableOfContents.Add(fxName, offset); + } + } + + private void ProcessEffects(BinaryReader binaryReader, IndentedTextWriter fileStream) + { + try + { + foreach (var kvp in this.tableOfContents) + { + this.ProcessEffect(binaryReader, fileStream, kvp.Key, kvp.Value); + } + } + catch (Exception e) + { + logger.Error(e.Message); + return; + } + } + + private void ProcessEffect( + BinaryReader reader, + IndentedTextWriter fileStream, + string name, + int offset) + { + logger.Info($"Processing '{name}'"); + + reader.BaseStream.Position = offset; + + fileStream.WriteLine($"fxdef {name}"); + fileStream.Indent = 1; + + int lastOpcode = 0; + try + { + while (true) + { + int opcode = reader.ReadByte(); + if (!this.macroDefinitionTable.MacroDefinitions.TryGetValue(opcode, out FxMacroDefinition macroDefinition)) + { + throw new InvalidOperationException("Unable to map opcode to macro definition"); + } + + if (opcode == this.doneOpcode) + { + fileStream.Indent--; + break; + } + + if (lastOpcode == this.pushObjOpcode) + { + fileStream.Indent++; + } + + var lineBuilder = new StringBuilder(); + lineBuilder.Append(macroDefinition.Name); + lineBuilder.Append(" "); + foreach (var line in macroDefinition.FxDefGroup) + { + string stringValue = line switch + { + DataDefinitionMacroLine primitiveMacroLine => primitiveMacroLine.Deserialize(reader, this.macroDefinitionTable.SymbolTable), + _ => throw new NotSupportedException() + }; + + lineBuilder.Append(stringValue); + lineBuilder.Append(" "); + } + + if (opcode == this.popObjOpcode) + { + fileStream.Indent--; + } + + fileStream.WriteLine(lineBuilder); + fileStream.Flush(); + + lastOpcode = opcode; + } + } + catch (Exception e) + { + logger.Error($"Exception processing {name}, last opcode was {lastOpcode}. Trace: {e}"); + } + + fileStream.WriteLine("fxdone" + Environment.NewLine); + } + } +} \ No newline at end of file diff --git a/Giants.EffectCompiler/Definitions.json b/Giants.EffectCompiler/Definitions.json new file mode 100644 index 0000000..3d0873f --- /dev/null +++ b/Giants.EffectCompiler/Definitions.json @@ -0,0 +1,7894 @@ +{ + "SymbolTable": { + "symbols": { + "ObjGroup": { + "ObjGroupOtherStuff": 0, + "ObjGroupCreatures": 1, + "ObjGroupPier_Bits": 2, + "ObjGroupSmartie_Stuff": 3, + "ObjGroupBigWalls": 4, + "ObjGroupReaper_fortress": 5, + "ObjGroupeffects": 6, + "ObjGroupMecc_stuff": 7, + "ObjGroupKab_stuff": 8, + "ObjGroupMecc_Base": 9, + "ObjGroupReaper_Base": 10, + "ObjGroupTools": 11, + "ObjGroupPlants": 12, + "ObjGroupFormations": 13, + "ObjGroupReaper_stuff": 14, + "ObjGroupGuard_Buildings": 15, + "ObjGroupAmbient": 16 + }, + "ObjData": { + "ObjDataIntroStart": 1, + "ObjDataIntroLogo": 2, + "ObjDataMCGun0": 3, + "ObjDataStream": 4, + "ObjDataWindTunnel": 5, + "ObjDataE_Wave": 6, + "ObjDataMCShotGun": 7, + "ObjDataMCSyringe": 8, + "ObjDataKabuto0": 10, + "ObjDataKabuto1": 11, + "ObjDataKabuto2": 12, + "ObjDataKabuto3": 13, + "ObjDataKabuto1PArms": 18, + "ObjDataKabuto1PMouth": 19, + "ObjDataMecc0": 20, + "ObjDataMecc1": 21, + "ObjDataMecc2": 22, + "ObjDataMecc3": 23, + "ObjDataMecc4": 24, + "ObjDataMecc5": 25, + "ObjDataMecc6": 26, + "ObjDataMecc7": 27, + "ObjDataMecc1P": 29, + "ObjDataReaper0": 30, + "ObjDataReaper1": 31, + "ObjDataReaper2": 32, + "ObjDataReaper3": 33, + "ObjDataReaper4": 34, + "ObjDataReaper5": 35, + "ObjDataReaper6": 36, + "ObjDataReaper7": 37, + "ObjDataLander": 40, + "ObjDataStation0": 50, + "ObjDataStation2": 51, + "ObjDataStation3": 52, + "ObjDataStation4": 53, + "ObjDataBoat0": 60, + "ObjDataBoat3": 61, + "ObjDataShip1": 70, + "ObjDataShip2": 71, + "ObjDataShip3": 72, + "ObjDataVimp0": 80, + "ObjDataVimp1": 81, + "ObjDataVimp2": 82, + "ObjDataVimp3": 83, + "ObjDataVimp4": 84, + "ObjDataVimp5": 85, + "ObjDataVimp6": 86, + "ObjDataVimp7": 87, + "ObjDataSven0": 90, + "ObjDataTofo0": 100, + "ObjDataSmartie0": 110, + "ObjDataSmartie1": 111, + "ObjDataSmartie2": 112, + "ObjDataSmartie3": 113, + "ObjDataSmartie4": 114, + "ObjDataSmartie5": 115, + "ObjDataSmartie6": 116, + "ObjDataSmartie7": 117, + "ObjDataMC_Body0": 120, + "ObjDataMCGiant": 130, + "ObjDataHerdGen": 199, + "ObjDataRWTornadoF": 200, + "ObjDataShawn1": 201, + "ObjDataShawn2": 202, + "ObjDataStatus": 203, + "ObjDataRWTornado": 204, + "ObjDataCannon": 205, + "ObjDataCannonBall": 206, + "ObjDatam_base": 207, + "ObjDatanaked_raw": 208, + "ObjDataMCBullet": 209, + "ObjDatamc_laser": 210, + "ObjDataK_altar": 211, + "ObjDatatest_oasis": 212, + "ObjDataMCBeamRing": 213, + "ObjDataMCLaserGun": 214, + "ObjDataMCzip": 215, + "ObjDataShawn3": 216, + "ObjDataShawn4": 217, + "ObjDataRPglow": 219, + "ObjDataRPglow2": 218, + "ObjDataRPbow0": 220, + "ObjDataRW_warning": 230, + "ObjDataTongueScene3": 251, + "ObjDataRParrow": 260, + "ObjDataRPfire": 261, + "ObjDataMCbush": 270, + "ObjDataKBTrap": 280, + "ObjDataEXFlash": 290, + "ObjDataEXSmokeRing": 291, + "ObjDataEXSmokeEven": 292, + "ObjDataEXSmokeOdd": 293, + "ObjDataMCSuit": 294, + "ObjDataIntro_1": 295, + "ObjDataIntro_2": 296, + "ObjDatapub": 297, + "ObjDatasm_fence": 298, + "ObjDatarockbush": 299, + "ObjDatamc_turret": 300, + "ObjDataShawn5": 301, + "ObjDataShawn6": 302, + "ObjDataShawn7": 303, + "ObjDataShawn8": 304, + "ObjDataShawn9": 305, + "ObjDatasm_pit": 310, + "ObjDatasm_glow": 311, + "ObjDatasmbottle": 312, + "ObjDataRipper": 320, + "ObjDatarip_l1": 321, + "ObjDatarip_l2": 322, + "ObjDatarip_l3": 323, + "ObjDatarip_l4": 324, + "ObjDatarip_l5": 325, + "ObjDatarip_l6": 326, + "ObjDataPub_l1": 330, + "ObjDataPub_l2": 331, + "ObjDataPub_l3": 332, + "ObjDataPub_l4": 333, + "ObjDatasmoke": 340, + "ObjDatamcthrust": 341, + "ObjDatamcthrust2": 342, + "ObjDataBlueprint": 345, + "ObjDatapub_stool": 346, + "ObjDataqueen_spikes": 347, + "ObjDataMCMachineGun": 348, + "ObjDataMCGrenade": 349, + "ObjDataChunk1": 400, + "ObjDataChunk2": 401, + "ObjDataVPChunk1": 402, + "ObjDataVPChunk2": 403, + "ObjDataVPCarcass": 404, + "ObjDataRip_gore_head": 405, + "ObjDataRip_gore_arm": 406, + "ObjDataChunk3": 407, + "ObjDataN_tree1": 500, + "ObjDataN_bunchoftrees": 501, + "ObjDataML_hive": 502, + "ObjDataML_Guardtower_l01": 503, + "ObjDataML_Brute": 504, + "ObjDataML_Reed1": 505, + "ObjDataML_Reed2": 506, + "ObjDataML_Reed3": 507, + "ObjDataML_Reed_L10": 508, + "ObjDataML_Reed_L05": 509, + "ObjDataML_Reed_L02": 510, + "ObjDataML_Reed_L11": 511, + "ObjDataML_Guardtower": 512, + "ObjDataSM_trap2": 516, + "ObjDataNick_Rbush": 517, + "ObjDataRM_seamonster": 520, + "ObjDataKS_Shepherd": 521, + "ObjDataRock_1": 530, + "ObjDataRock_2": 531, + "ObjDataBigRock": 532, + "ObjDataRM_jelly": 533, + "ObjDataPier": 534, + "ObjDataN_5ftrock_1": 535, + "ObjDataN_20ftrock_1": 536, + "ObjDataRipSpit": 537, + "ObjDataJ_chunk1": 538, + "ObjDataJ_chunk2": 539, + "ObjDataJ_chunk3": 540, + "ObjDataRock_3": 541, + "ObjDatab_bush": 542, + "ObjDatab_pod": 543, + "ObjDatab_pod_l1": 544, + "ObjDataKS_Rock1": 545, + "ObjDataKS_Rock2": 546, + "ObjDataKS_Rock3": 547, + "ObjDataKS_SmRock1": 548, + "ObjDataKS_SmRock2": 549, + "ObjDatab_pod_l2": 550, + "ObjDatab_bush_l1": 551, + "ObjDataRock_3_l1": 552, + "ObjDatamc_turret_l2": 553, + "ObjDataRipFire": 554, + "ObjDataG_Smoke": 555, + "ObjDataKS_L1": 556, + "ObjDataKS_L2": 557, + "ObjDataKS_L3": 558, + "ObjDataKS_shadow": 559, + "ObjDataRM_L1": 560, + "ObjDataRM_L2": 561, + "ObjDataRM_L3": 562, + "ObjDataRM_L4": 563, + "ObjDataRM_L5": 564, + "ObjDataML_GT_L1": 565, + "ObjDataML_GT_L2": 566, + "ObjDataML_GT_L3": 567, + "ObjDataML_GT_L4": 568, + "ObjDataML_Hive_L1": 569, + "ObjDataML_Hive_L2": 570, + "ObjDataPier_Collision": 571, + "ObjDataPtree": 572, + "ObjDataPtree_L1": 573, + "ObjDataPtree_L2": 574, + "ObjDataPtree_L3": 575, + "ObjDataPtree_L4": 576, + "ObjDataPtree_bob": 577, + "ObjDataN_bush_tall": 578, + "ObjDataN_bush_flat": 579, + "ObjDataN_bush_vtall": 580, + "ObjDataN_bush_small": 581, + "ObjDataN_tree_flat": 582, + "ObjDataPtree_bob_l1": 583, + "ObjDataPtree_bob_l2": 584, + "ObjDataTora": 585, + "ObjDataKabutoCollision": 586, + "ObjDataDust": 587, + "ObjDatapub_smash1": 588, + "ObjDataO2_rock8": 589, + "ObjDataO2_rock20": 590, + "ObjDataO2_rock50": 591, + "ObjDataWhipFlash": 592, + "ObjDataWhipRing": 593, + "ObjDataTora_l1": 594, + "ObjDataTora_l2": 595, + "ObjDataTora_l3": 596, + "ObjDataO1_pad": 597, + "ObjDataColl_station": 598, + "ObjDataMecc_NT": 600, + "ObjDatabridge": 601, + "ObjDatabridge_coll": 602, + "ObjDatawater_rings": 605, + "ObjDatasveed_l0": 610, + "ObjDatasveed_l4": 614, + "ObjDatasveed_l6": 616, + "ObjDatasveed_target": 620, + "ObjDataFlak_l0": 624, + "ObjDataFlak_l1": 625, + "ObjDatab_leaf1": 626, + "ObjDataMcflag": 627, + "ObjDataLobird_l0": 628, + "ObjDatashiner": 632, + "ObjDatas_weeds": 635, + "ObjDataM_door1_L1": 636, + "ObjDatab_lilly": 639, + "ObjDataM_thudgun": 640, + "ObjDataM_thudgun_L1": 641, + "ObjDataMC_gun_rotate": 642, + "ObjDataSquare": 643, + "ObjDataM_blueglow": 644, + "ObjDatawater_drip": 645, + "ObjDatas_flower1": 648, + "ObjDataPtree_bob_l3": 654, + "ObjDataPtree_bob_l4": 655, + "ObjDataPtree_bob_l5": 656, + "ObjDataPtree_bob_l6": 657, + "ObjDataPtree_bob_l7": 658, + "ObjDataM_airlock1_l0": 700, + "ObjDataM_airlock2_l0": 701, + "ObjDataM_airlock3_l0": 702, + "ObjDataM_airlock1_l1": 703, + "ObjDataM_airlock2_l1": 704, + "ObjDataM_airlock3_l1": 705, + "ObjDataM_coll_hatch": 749, + "ObjDataM_coll_airlock": 750, + "ObjDataM_hatch_l0": 751, + "ObjDataM_hatch_l1": 752, + "ObjDataM_hotfloor": 753, + "ObjDataR_husk": 754, + "ObjDataR_husk_damage1": 755, + "ObjDataR_husk_damage2": 756, + "ObjDataR_husk_chunk_1": 757, + "ObjDataR_husk_chunk_2": 758, + "ObjDataR_husk_chunk_3": 759, + "ObjDataR_husk_chunk_4": 760, + "ObjDatamcjetpack": 765, + "ObjDatarip_clamp": 766, + "ObjDataSM_wall2": 767, + "ObjDataQ3_pillars": 768, + "ObjDatamecc_crash1": 770, + "ObjDatamecc_crash1_coll": 771, + "ObjDataDact_nest": 772, + "ObjDataDact_temp": 773, + "ObjDataRW_cannonflash": 774, + "ObjDataM_lander_l0": 780, + "ObjDataM_lander_l1": 781, + "ObjDataM_lander_l2": 782, + "ObjDataM_lander_l3": 783, + "ObjDataM_lander_l4": 784, + "ObjDataM_lander_l5": 785, + "ObjDataM_lander_l6": 786, + "ObjDataM_lander_l7": 787, + "ObjDataM_lander_s0": 788, + "ObjDataDactyl_l0": 790, + "ObjDataDact_egg": 791, + "ObjDataTir_l0": 800, + "ObjDataRPMAN": 810, + "ObjDataRPMAN_l1": 811, + "ObjDataRPMAN_l2": 812, + "ObjDataRPMAN_l3": 813, + "ObjDataRPMAN_l4": 814, + "ObjDataRPMAN_l5": 815, + "ObjDataRPMAN_l6": 816, + "ObjDataRPMAN_l7": 817, + "ObjDataRpm_horn": 818, + "ObjDataRpm_Spear": 819, + "ObjDatasmf_l0": 820, + "ObjDataRipnest": 828, + "ObjDataRipnest_X": 829, + "ObjDataMound": 832, + "ObjDataDirt1": 835, + "ObjDataFeather1": 837, + "ObjDatarip_clamp_X": 838, + "ObjDatarip_clamp_Shell": 839, + "ObjDataSM_ruins": 840, + "ObjDataC3_pier": 850, + "ObjDataC3_smartiebase": 851, + "ObjDataC3_kab_wall": 852, + "ObjDataC3_sniper_tower": 853, + "ObjDataC3_gateway": 854, + "ObjDataGatedoor_l0": 855, + "ObjDataC3_kab_wall_l1": 856, + "ObjDataKab_shadow": 857, + "ObjDataC3_soon": 858, + "ObjDataSB_brick": 859, + "ObjDataC3_gate_coll": 860, + "ObjDataC3_scene_wall": 861, + "ObjDataDactyl_l2": 862, + "ObjDataBridge_end": 863, + "ObjDataBridge_end_coll": 864, + "ObjDataBridge_100ft": 865, + "ObjDataBridge_200ft": 866, + "ObjDataBridge_300ft": 867, + "ObjDataM_back_range": 900, + "ObjDataM_back_wake": 901, + "ObjDataM_back_mother": 902, + "ObjDataM_back_damage": 903, + "ObjDataRipSpitBig": 904, + "ObjDataSm_fork": 905, + "ObjDataSm_Knife": 906, + "ObjDataSmbush": 907, + "ObjDataSeaport_wall": 908, + "ObjDataSmhouse1": 910, + "ObjDataBW_arch_100": 920, + "ObjDataBW_arch_150": 921, + "ObjDataBW_arch_200": 922, + "ObjDataBW_corner": 923, + "ObjDataBW_wall_100": 924, + "ObjDataSR_tower": 925, + "ObjDataSR_tower_arm": 926, + "ObjDataSR_tower_ring": 944, + "ObjDatasm_boat_L0": 945, + "ObjDatasm_boat_L1": 946, + "ObjDatasm_boat_L2": 947, + "ObjDatasm_boat_L3": 948, + "ObjDatasm_cart_L0": 949, + "ObjDatasm_cart_L1": 950, + "ObjDatasm_cart_L2": 951, + "ObjDatasm_cart_L3": 952, + "ObjDatasm_chimney_L0": 953, + "ObjDatasm_chimney_L1": 954, + "ObjDatasm_dome_L0": 955, + "ObjDatasm_dome_L1": 956, + "ObjDatasm_dome_L2": 957, + "ObjDatasm_dome_L3": 958, + "ObjDatasm_domeD1_L0": 959, + "ObjDatasm_domeD1_L1": 960, + "ObjDatasm_door_L0": 961, + "ObjDatasm_door_L1": 962, + "ObjDatasm_door_L2": 963, + "ObjDatasm_door_L3": 964, + "ObjDatasm_fences_L0": 965, + "ObjDatasm_fences_L1": 966, + "ObjDatasm_fences_L2": 967, + "ObjDatasm_seat_L0": 968, + "ObjDatasm_seat_L1": 969, + "ObjDatasm_table_L0": 970, + "ObjDatasm_table_L1": 971, + "ObjDatasm_tower_L0": 972, + "ObjDatasm_tower_L1": 973, + "ObjDatasm_tower_L2": 974, + "ObjDatasm_tower_L3": 975, + "ObjDatasm_well_L0": 976, + "ObjDatasm_well_L1": 977, + "ObjDatasm_well_L2": 978, + "ObjDatasm_window_L0": 979, + "ObjDatasm_window_L1": 980, + "ObjDatasm_window_L2": 981, + "ObjDatasm_tube_L0": 982, + "ObjDatasm_tube_L1": 983, + "ObjDatasm_tube_L2": 984, + "ObjDatasm_tube_L3": 985, + "ObjDatasm_ladder_L0": 986, + "ObjDatasm_ladder_L1": 987, + "ObjDatasm_fences2_L0": 988, + "ObjDatasm_fences2_L1": 989, + "ObjDatasm_post_L0": 990, + "ObjDatasm_post_L1": 991, + "ObjDatasm_hatch_L0": 992, + "ObjDatasm_hatch_L1": 993, + "ObjDatasm_Vconnect1": 994, + "ObjDatasm_Vconnect2": 995, + "ObjDatasm_sphere": 996, + "ObjDatasm_sphere2": 998, + "ObjDatabridge_400ft": 999, + "ObjDatasm_spheredark": 1000, + "ObjDatasm_spheredark2": 1001, + "ObjDatasm_post_tall": 1002, + "ObjDatabridge_500ft": 1003, + "ObjDatapier_straight": 1004, + "ObjDatapier_bend90": 1005, + "ObjDatapier_round_rings": 1006, + "ObjDatapier_round_tile": 1007, + "ObjDatapier_square": 1008, + "ObjDatapier_post20": 1009, + "ObjDatapier_post30": 1010, + "ObjDatapier_post40": 1011, + "ObjDatashadow_round": 1012, + "ObjDatashadow_elipse": 1013, + "ObjDatashadow_elipse2": 1014, + "ObjDatasmW_entrance": 1015, + "ObjDatasmW_curvehi": 1016, + "ObjDatasmW_column": 1017, + "ObjDatasmW_curvemed": 1018, + "ObjDatasmW_curvelow": 1019, + "ObjDatasmW_column2": 1020, + "ObjDatasmW_cwall_low": 1021, + "ObjDatasmW_wall_hi": 1022, + "ObjDatasmW_wall_med": 1023, + "ObjDatasmW_wall_hi_hole": 1024, + "ObjDataSR_FORTLEGS_L0": 1025, + "ObjDataSR_FORTLEGS_L1": 1026, + "ObjDataSR_FORTLEGS_L2": 1027, + "ObjDataSR_FORTLEGS_L3": 1028, + "ObjDataBW_gate_portcullis": 1029, + "ObjDataBW_wall_150": 1030, + "ObjDataBW_wall_200": 1031, + "ObjDataBW_parapit": 1032, + "ObjDataBW_sr_arch_100": 1033, + "ObjDataBW_sr_corner": 1034, + "ObjDatasr_mtower": 1035, + "ObjDataverm_L0": 1036, + "ObjDataverm_L1": 1037, + "ObjDataverm_L2": 1038, + "ObjDataverm_L3": 1039, + "ObjDataverm_L4": 1040, + "ObjDataverm_L5": 1041, + "ObjDataCanopy_1": 1042, + "ObjDatabent_post": 1043, + "ObjDatapier_straight_80": 1044, + "ObjDatapier_straight_160": 1045, + "ObjDataBW_column_20": 1046, + "ObjDataBW_column_30": 1047, + "ObjDataBW_column_40": 1048, + "ObjDataBW_column_60": 1049, + "ObjDataverm_egg_L0": 1050, + "ObjDataverm_egg_L1": 1051, + "ObjDatacharger": 1054, + "ObjDatasonak_L0": 1055, + "ObjDatasonak_L1": 1056, + "ObjDatasonak_L2": 1057, + "ObjDatasonak_L3": 1058, + "ObjDatasonak_L4": 1059, + "ObjDatasonak_L5": 1060, + "ObjDatasonak_L6": 1061, + "ObjDatasonak_L7": 1062, + "ObjDataverm_egg_d1_L0": 1063, + "ObjDataverm_egg_d1_L1": 1064, + "ObjDataverm_eggshell1": 1065, + "ObjDataBW_bunker1": 1066, + "ObjDataBW_top_platform": 1067, + "ObjDataBW_top_connect1": 1068, + "ObjDataBW_turret": 1069, + "ObjDataBW_turret_gun": 1070, + "ObjDataSmTimmy_L0": 1071, + "ObjDataSmTimmy_L1": 1072, + "ObjDataSmTimmy_L2": 1073, + "ObjDataSmTimmy_L3": 1074, + "ObjDataSmTimmy_L4": 1075, + "ObjDataSmTimmy_L5": 1076, + "ObjDataSmTimmy_L6": 1077, + "ObjDataSmTimmy_L7": 1078, + "ObjDataSmBorjoyzee_L0": 1079, + "ObjDataSmBorjoyzee_L1": 1080, + "ObjDataSmBorjoyzee_L2": 1081, + "ObjDataSmBorjoyzee_L3": 1082, + "ObjDataSmBorjoyzee_L4": 1083, + "ObjDataSmBorjoyzee_L5": 1084, + "ObjDataSmBorjoyzee_L6": 1085, + "ObjDataSmBorjoyzee_L7": 1086, + "ObjDataTurret_gun": 1087, + "ObjDatasonak_seat_L0": 1088, + "ObjDatasonak_seat_L1": 1089, + "ObjDataBW_wall_100_window": 1090, + "ObjDataBW_bunker_low": 1091, + "ObjDatasmW_curvehi_m": 1092, + "ObjDataverm_L6": 1093, + "ObjDataverm_L7": 1094, + "ObjDatasmW_house1": 1095, + "ObjDatasmW_house2": 1096, + "ObjDatasmW_house3": 1097, + "ObjDatasmW_house4": 1098, + "ObjDatasmW_curvemed_m": 1099, + "ObjDatasmW_curvelow_m": 1100, + "ObjDatasm_dome_L4": 1101, + "ObjDatasm_sphere_l1": 1102, + "ObjDatasm_sphere_l2": 1103, + "ObjDatasm_spheredark_l1": 1104, + "ObjDatasm_spheredark_l2": 1105, + "ObjDatasm_canopy_1_blue": 1106, + "ObjDatasm_canopy_1_red": 1107, + "ObjDatasm_canopy_1_green": 1108, + "ObjDataSM_PANEL": 1109, + "ObjDatafort_buttress_L0": 1116, + "ObjDatafort_buttress_L1": 1117, + "ObjDatafort_buttress_L2": 1118, + "ObjDataBW_sr_arch_150": 1119, + "ObjDataBW_sr_arch_200": 1120, + "ObjDatafort_slab": 1121, + "ObjDatafort_statue": 1122, + "ObjDatafort_drain_L0": 1123, + "ObjDatafort_drain_L1": 1124, + "ObjDatasm_raft_L0": 1125, + "ObjDatasm_raft_L1": 1126, + "ObjDatasm_raft_L2": 1127, + "ObjDatasm_raft_L3": 1128, + "ObjDatasonak_ring": 1129, + "ObjDatacharger_l1": 1130, + "ObjDatacharger_l2": 1131, + "ObjDatacharger_l3": 1132, + "ObjDatacharger_l4": 1133, + "ObjDatacharger_l5": 1134, + "ObjDatacharger_l6": 1135, + "ObjDataturret_shell": 1136, + "ObjDataPtree_simple": 1137, + "ObjDatarpman_tracer": 1138, + "ObjDataBW_debri_piece1": 1139, + "ObjDataBW_debri_piece2": 1140, + "ObjDataBW_debri_piece3": 1141, + "ObjDataBW_debri_piece4": 1142, + "ObjDataBW_debri_column1": 1143, + "ObjDataBW_debri_column2": 1144, + "ObjDataBW_debri_bunker1": 1145, + "ObjDatashadow_blastmark_1": 1146, + "ObjDatashadow_blastmark_2": 1147, + "ObjDatadust_ring": 1148, + "ObjDatawater_spray": 1149, + "ObjDatadust_blast": 1150, + "ObjDatamuzzle_flash": 1151, + "ObjDatarpman_grenade": 1152, + "ObjDatarpman_gunseat_L0": 1153, + "ObjDatarpman_gunseat_L1": 1154, + "ObjDatarpman_gunseat_L2": 1155, + "ObjDatadummy": 1156, + "ObjDatamuzzle_flash2": 1157, + "ObjDatadust_flash": 1158, + "ObjDataripnest_chunk": 1159, + "ObjDatarpman_chunk_head": 1160, + "ObjDatarpman_chunk_body": 1161, + "ObjDatarpman_chunk_hand": 1162, + "ObjDataShrap_Bigwall_1": 1163, + "ObjDataShrap_Bigwall_2": 1164, + "ObjDataShrap_Bigwall_3": 1165, + "ObjDataShrap_Bigwall_4": 1166, + "ObjDataShrap_Wood_1": 1167, + "ObjDataShrap_Wood_2": 1168, + "ObjDataShrap_Wood_3": 1169, + "ObjDataShrap_Wood_4": 1170, + "ObjDataShrap_Rock_1": 1171, + "ObjDataShrap_Rock_2": 1172, + "ObjDataShrap_Rock_3": 1173, + "ObjDataShrap_Rock_4": 1174, + "ObjDataShrap_Plant_1": 1175, + "ObjDataShrap_Plant_2": 1176, + "ObjDataShrap_Plant_3": 1177, + "ObjDataShrap_Plant_4": 1178, + "ObjDatarpman_chunk_main": 1179, + "ObjDataShrap_Ground": 1180, + "ObjDatamc_pickup_shells": 1181, + "ObjDatamc_pickup_clips": 1182, + "ObjDatamc_pickup_health": 1183, + "ObjDatamc_pickup_grenades": 1184, + "ObjDatamc_pickup_bush": 1185, + "ObjDataBW_bunker1_D1": 1186, + "ObjDataBW_bunker_top": 1187, + "ObjDataBW_bunker_low_D1": 1188, + "ObjDataBW_column_20_D1": 1189, + "ObjDataBW_column_30_D1": 1190, + "ObjDataBW_column_40_D1": 1191, + "ObjDataBW_column_60_D1": 1192, + "ObjDatamc_machinegun": 1193, + "ObjDataBW_parapit_D1": 1194, + "ObjDatamc_machinegun_shell": 1195, + "ObjDatarpman_machinegun_shell": 1196, + "ObjDataMCMuzzle_Flash": 1197, + "ObjDataMCMuzzle_Flash2": 1198, + "ObjDataptree_bob_d1": 1199, + "ObjDataptree_bob_damage1": 1200, + "ObjDatasm_staff": 1201, + "ObjDatarpqueen_L0": 1202, + "ObjDatarpqueen_L1": 1203, + "ObjDatarpqueen_L2": 1204, + "ObjDatarpqueen_L3": 1205, + "ObjDatarpqueen_L4": 1206, + "ObjDatarpqueen_L5": 1207, + "ObjDatarpqueen_L6": 1208, + "ObjDatarpqueen_L7": 1209, + "ObjDatablast_ring": 1210, + "ObjDatamc_shotgun_blast": 1211, + "ObjDatarp_sword": 1212, + "ObjDatasm_borj_house_l0": 1213, + "ObjDatadust_ball": 1222, + "ObjDatadust_smoke": 1223, + "ObjDatareaper_test": 1224, + "ObjDatamud_patch": 1225, + "ObjDatamud_ball": 1228, + "ObjDatahot_rock": 1229, + "ObjDataMarker": 1230, + "ObjDatarock_rpman_1": 1231, + "ObjDatarock_rpman_2": 1232, + "ObjDatahot_rock_D": 1233, + "ObjDatalog_carrier": 1234, + "ObjDatasmell": 1239, + "ObjDatacleaner_L0": 1240, + "ObjDatacleaner_L1": 1241, + "ObjDatacleaner_L2": 1242, + "ObjDatabarracks": 1243, + "ObjDatarock_rpman_3": 1244, + "ObjDatalog_launcher": 1245, + "ObjDatalog_launcher_base": 1246, + "ObjDatahitcher": 1247, + "ObjDataturret_gun_D": 1248, + "ObjDataBarracks_D": 1249, + "ObjDatarpman_tuba": 1250, + "ObjDatamud_mold_dry": 1251, + "ObjDatamud_mold_wet": 1252, + "ObjDatacast_spell": 1253, + "ObjDatarain": 1254, + "ObjDatamud_mold_wet1": 1255, + "ObjDatamud_mold_wet2": 1256, + "ObjDatamud_mold_wet3": 1257, + "ObjDatamud_mold_wet4": 1258, + "ObjDataRpbomb": 1259, + "ObjDatadelphi_dust": 1260, + "ObjDatadelphi_dust_ball": 1261, + "ObjDatabridge_200ft_d": 1262, + "ObjDataplank1": 1263, + "ObjDataplank2": 1264, + "ObjDatabw_column_40_b": 1265, + "ObjDataapple": 1266, + "ObjDataWood_fence": 1267, + "ObjDataWood_wall": 1268, + "ObjDataWood_gift": 1269, + "ObjDataWood_pub": 1270, + "ObjDataWood_shop": 1271, + "ObjDataWood_turret": 1272, + "ObjDataStone_wall": 1273, + "ObjDataStone_pub": 1274, + "ObjDataStone_gift": 1275, + "ObjDataStone_shop": 1276, + "ObjDataStone_turret": 1277, + "ObjDataMetal_shop": 1278, + "ObjDataMetal_pub": 1279, + "ObjDataMetal_turret": 1280, + "ObjDatagift": 1281, + "ObjDataMetal_gift": 1282, + "ObjDataMetal_bunker": 1283, + "ObjDataMetal_wall": 1284, + "ObjDataShield_Extractor_1": 1285, + "ObjDataShield_Extractor_2": 1286, + "ObjDataShield_Extractor_3": 1287, + "ObjDataExtractor_1": 1288, + "ObjDataExtractor_2": 1289, + "ObjDataExtractor_3": 1290, + "ObjDataRp_pub_1": 1291, + "ObjDataRp_pub_2": 1292, + "ObjDataRp_pub_3": 1293, + "ObjDataSpellshop_1": 1294, + "ObjDataSpellshop_2": 1295, + "ObjDataSpellshop_3": 1296, + "ObjDataRp_pier": 1297, + "ObjDataShield_1": 1298, + "ObjDataShield_2": 1299, + "ObjDataShield_3": 1300, + "ObjDatasmyan_L0": 1301, + "ObjDatasmyan_L1": 1302, + "ObjDatasmyan_L2": 1303, + "ObjDatasmyan_L3": 1304, + "ObjDatasmyan_L4": 1305, + "ObjDatasmyan_L5": 1306, + "ObjDatasmyan_L6": 1307, + "ObjDatasmyan_L7": 1308, + "ObjDataDeep_sea_monster": 1309, + "ObjDataWood_gate": 1310, + "ObjDataoffspring_L0": 1311, + "ObjDataoffspring_L1": 1312, + "ObjDataoffspring_L2": 1313, + "ObjDataoffspring_L3": 1314, + "ObjDataoffspring_L4": 1315, + "ObjDataoffspring_L5": 1316, + "ObjDataoffspring_L6": 1317, + "ObjDataoffspring_L7": 1318, + "ObjDataoffspring_egg_l0": 1319, + "ObjDataoffspring_egg_d1_l0": 1320, + "ObjDataoffspring_eggshell1": 1321, + "ObjDatakb_hotspot": 1322, + "ObjDatasm_firepit": 1323, + "ObjDataCOL_sm_firepit": 1324, + "ObjDatasm_table_full": 1325, + "ObjDatasm_shovel": 1326, + "ObjDatasm_tankard": 1327, + "ObjDatasm_hammer": 1328, + "ObjDatasm_saw": 1329, + "ObjDatasm_drumstick": 1330, + "ObjDatasm_ribs": 1331, + "ObjDatasm_pool": 1332, + "ObjDatasm_podium": 1333, + "ObjDatasm_planks": 1334, + "ObjDatasm_woodshop_pile": 1335, + "ObjDataD_wood_shop": 1336, + "ObjDataD_stone_gift": 1337, + "ObjDataD_stone_shop": 1338, + "ObjDataD_metal_shop": 1339, + "ObjDataD_metal_gift": 1340, + "ObjDatad_wood_gift": 1341, + "ObjDataD_wood_wall": 1342, + "ObjDataD_metal_wall": 1343, + "ObjDataD_stone_wall": 1344, + "ObjDataD_wood_gate": 1345, + "ObjDataD_stone_gate": 1346, + "ObjDataD_metal_gate": 1347, + "ObjDatastone_gate": 1348, + "ObjDatametal_gate": 1349, + "ObjDataD_Metal_pub": 1350, + "ObjDataD_Stone_pub": 1351, + "ObjDataD_Wood_pub": 1352, + "ObjDatatemp2": 1353, + "ObjDataMcthrust_nitro": 1354, + "ObjDatasm_bricks": 1355, + "ObjDatasm_metal": 1356, + "ObjDatarock_waiting": 1357, + "ObjDatamc_launcher": 1358, + "ObjDatamecctest": 1359, + "ObjDatamc_snipergun": 1360, + "ObjDatasm_book": 1361, + "ObjDatarock_waiting_coll": 1362, + "ObjDatamc_mortar": 1363, + "ObjDataN_test": 1364, + "ObjDatamc_pickup_sn_clips": 1365, + "ObjDatamc_sniper_bullit": 1366, + "ObjDataEFX_flash": 1367, + "ObjDataEFX_cloud": 1368, + "ObjDataEFX_debri1": 1369, + "ObjDataEFX_debri2": 1370, + "ObjDataEFX_fireball": 1371, + "ObjDataEfx_shockwave": 1372, + "ObjDatamc_rocket": 1373, + "ObjDatamc_pickup_rockets": 1374, + "ObjDatamc_pickup_lbombs": 1375, + "ObjDatamc_rocket_proximity": 1376, + "ObjDatamc_pickup_proximity": 1377, + "ObjDataMC_mine": 1378, + "ObjDatamc_rocket_homing": 1379, + "ObjDatamc_pickup_homing": 1380, + "ObjDatamc_lbomb": 1381, + "ObjDatas6_dungeon": 1382, + "ObjDatas6_cage": 1383, + "ObjDataEFX_shockwave_W": 1384, + "ObjDataEFX_cloud_dark": 1385, + "ObjDataEFX_dustball": 1386, + "ObjDataEFX_smoke_black": 1387, + "ObjDataEFX_fire_trail": 1388, + "ObjDataEFX_shockwave_B": 1389, + "ObjDataEFX_ref_horiz_circle": 1390, + "ObjDataEFX_ref_sphere": 1391, + "ObjDataEFX_ref_plume": 1392, + "ObjDataEFX_Bfire_trail": 1393, + "ObjDataEFX_ref_line_back": 1394, + "ObjDatamc_popupbomb": 1395, + "ObjDataEFX_ref_line_up": 1396, + "ObjDataEFX_shockwave_BH": 1397, + "ObjDataEFX_smoke_blue": 1399, + "ObjDataEFX_Gfire_trail": 1400, + "ObjDataEFX_smoke_Mgrey": 1401, + "ObjDataEFX_sniper_flash": 1402, + "ObjDatasnowtree": 1403, + "ObjDataWood_turret_gun": 1404, + "ObjDataMetal_turret_gun": 1405, + "ObjDataStone_turret_gun": 1406, + "ObjDatasm_dropoff": 1407, + "ObjDatabase_flag_red": 1408, + "ObjDatabase_flag_blue": 1409, + "ObjDataEFX_ref_line_L2R": 1410, + "ObjDataStone_wall_coll": 1411, + "ObjDataEFX_wind_arrow": 1412, + "ObjDataEFX_rain": 1413, + "ObjDataEFX_snow": 1414, + "ObjDataEFX_hail": 1415, + "ObjDataEFX_shield_1": 1416, + "ObjDataEFX_shield_2": 1417, + "ObjDataEFX_shield_3": 1418, + "ObjDataEFX_waterdrop": 1419, + "ObjDataEFX_glint": 1420, + "ObjDataEFX_bubble_reflection": 1421, + "ObjDataEFX_bubble_hilight": 1422, + "ObjDataEFX_bubble_glow": 1423, + "ObjDataRP_smartie_waiting": 1424, + "ObjDataEFX_spellshop_base": 1425, + "ObjDataEFX_spellshop_window_y": 1426, + "ObjDataEFX_water_ring": 1427, + "ObjDataEFX_spellshop_window_r": 1428, + "ObjDataEFX_spellshop_window_g": 1429, + "ObjDatasm_podium_reap": 1430, + "ObjDatasm_dropoff_reap": 1431, + "ObjDataEFX_vimp_ghost": 1432, + "ObjDataRP_pier_boat": 1433, + "ObjDataEFX_water_bubble": 1434, + "ObjDataEFX_ref_bubbles": 1435, + "ObjDataWood_wall_coll": 1436, + "ObjDatasmblue_L0": 1437, + "ObjDatasmblue_L1": 1438, + "ObjDatasmblue_L2": 1439, + "ObjDatasmblue_L3": 1440, + "ObjDatasmblue_L4": 1441, + "ObjDatasmblue_L5": 1442, + "ObjDatasmblue_L6": 1443, + "ObjDatasmblue_L7": 1444, + "ObjDataCollision_test": 1445, + "ObjDataEFX_blast_area_check": 1446, + "ObjDataEFX_dust_ball": 1447, + "ObjDataEFX_dust_swirl": 1448, + "ObjDataEFX_mist": 1449, + "ObjDataEFX_shield_hit_p1": 1450, + "ObjDataRP_boat": 1451, + "ObjDataEFX_smartie_spell": 1452, + "ObjDataEFX_ref_ground_hit": 1453, + "ObjDataEFX_snow_ball": 1454, + "ObjDataEFX_snow_swirl": 1455, + "ObjDataRP_boat_guns": 1456, + "ObjDataRP_pier_coll": 1457, + "ObjDatasm_firepit_coll": 1458, + "ObjDataextractor_2_coll": 1459, + "ObjDataextractor_1_coll": 1460, + "ObjDataextractor_3_coll": 1461, + "ObjDatarp_soul_dropoff": 1462, + "ObjDataEFX_redlight": 1463, + "ObjDataMr_invisible": 1464, + "ObjDataefx_blue_wide": 1465, + "ObjDataefx_ref_reap": 1466, + "ObjDataEFX_ref_spin": 1467, + "ObjDataEFX_ref_firewall": 1468, + "ObjDataMetal_wall_coll": 1469, + "ObjDataEFX_fire": 1470, + "ObjDataStone_gate_coll": 1471, + "ObjDatamc_jetpack_2": 1472, + "ObjDataMetal_gate_coll": 1473, + "ObjDataEFX_slow_spell": 1474, + "ObjDataEFX_x": 1475, + "ObjDataEFX_x_vert": 1476, + "ObjDatamc_repairpack": 1477, + "ObjDatamc_repairgun": 1478, + "ObjDataEFX_lightning": 1479, + "ObjDataEFX_wood_debri_1": 1480, + "ObjDataEFX_wood_debri_2": 1481, + "ObjDatamc_shield": 1482, + "ObjDatarp_head": 1483, + "ObjDataEFX_hail_missile": 1484, + "ObjDataEFX_hail_shrapnel": 1485, + "ObjDatamc_chunk1": 1486, + "ObjDatamc_chunk2": 1487, + "ObjDatamc_chunk3": 1488, + "ObjDatamc_chunk4": 1489, + "ObjDatamc_chunk5": 1490, + "ObjDatamc_chunk6": 1491, + "ObjDataEFX_metal_debri_1": 1492, + "ObjDataEFX_stone_debri_1": 1493, + "ObjDataEFX_splat": 1494, + "ObjDataEFX_spray": 1495, + "ObjDataEFX_blood": 1496, + "ObjDataEFX_build_select": 1497, + "ObjDataFun_house": 1498, + "ObjDataEFX_mc_death": 1499, + "ObjDataRp_Sword_trail": 1500, + "ObjDataMC_bushpack": 1501, + "ObjDataEFX_circle_spell": 1502, + "ObjDataEFX_debri_3": 1503, + "ObjDataEFX_ref_circle_out": 1504, + "ObjDataEFX_ref_sphere_in": 1505, + "ObjDataEFX_rp_target": 1506, + "ObjDataEFX_prx_sphere": 1507, + "ObjDataEFX_fire_roll": 1508, + "ObjDataRP_bow_homing": 1509, + "ObjDataRP_Bow_Sniper": 1510, + "ObjDataRP_bow_rpg": 1511, + "ObjDataRP_Bow_powerup": 1512, + "ObjDataEFX_dark_fire": 1513, + "ObjDataEFX_box_alpha": 1514, + "ObjDataRP_Screamer": 1515, + "ObjDataEFX_Bglow": 1516, + "ObjDataD_fun_house": 1517, + "ObjDataScott_test": 1518, + "ObjDataEFX_blooddrop": 1519, + "ObjDataEFX_cloud_layer": 1520, + "ObjDataRP_turret_1_gun": 1521, + "ObjDataRP_turret_1": 1522, + "ObjDataEFX_ice_target": 1523, + "ObjDataEFX_red_smartie": 1524, + "ObjDataEFX_blue_smartie": 1525, + "ObjDataoffs_hotspot": 1526, + "ObjDataEFX_Swirl": 1527, + "ObjDataEFX_lightning_1": 1528, + "ObjDataEFX_lightning_2": 1529, + "ObjDataEFX_rainbow": 1530, + "ObjDataEFX_RP_debri_1": 1531, + "ObjDatasm_flag": 1532, + "ObjDatasm_flag1": 1533, + "ObjDatasm_flag2": 1534, + "ObjDatasm_flag3": 1535, + "ObjDataEFX_sun_yellow": 1536, + "ObjDataEFX_sun_yellow_f": 1537, + "ObjDataWood_pub_coll": 1538, + "ObjDataEFX_green_smartie": 1539, + "ObjDataEFX_clockhand_1": 1540, + "ObjDataEFX_clockhand_2": 1541, + "ObjDataD_wood_turret": 1542, + "ObjDataD_stone_turret": 1543, + "ObjDataD_metal_turret": 1544, + "ObjDataWood_wall_l8": 1545, + "ObjDataD_wood_gate_l8": 1546, + "ObjDatawood_gate_l8": 1547, + "ObjDatawood_shop_l8": 1548, + "ObjDatasm_firepit_l8": 1549, + "ObjDatad_wood_shop_l8": 1550, + "ObjDataD_wood_wall_l8": 1551, + "ObjDatastone_wall_l8": 1552, + "ObjDataMetal_wall_l8": 1553, + "ObjDataEFX_bow_charged": 1554, + "ObjDataMetal_pub_coll": 1555, + "ObjDataEFX_fire_ring": 1556, + "ObjDataEFX_splash": 1557, + "ObjDataD_spellshop_1": 1558, + "ObjDataD_spellshop_2": 1559, + "ObjDataD_spellshop_3": 1560, + "ObjDataD_extractor_2": 1561, + "ObjDataD_rp_pier": 1562, + "ObjDataD_rp_boat": 1563, + "ObjDataD_Extractor_3": 1564, + "ObjDataD_Shield_Extractor_1": 1565, + "ObjDataD_Shield_Extractor_2": 1566, + "ObjDataD_Shield_Extractor_3": 1567, + "ObjDataBone_femur": 1568, + "ObjDataBone_rib": 1569, + "ObjDataBone_spine": 1570, + "ObjDataEFX_3dXhair": 1571, + "ObjDataMecc_base_template_1": 1572, + "ObjDataS_mecc_bunker": 1573, + "ObjDataS_mecc_teleport": 1574, + "ObjDataS_mecc_Gpad": 1575, + "ObjDataRP_base_template_1": 1576, + "ObjDataS_mecc_shop": 1577, + "ObjDataS_mecc_shop_coll": 1578, + "ObjDataS_mecc_tower": 1579, + "ObjDataS_reaper_shop": 1580, + "ObjDataS_reaper_bunker": 1581, + "ObjDataGyro_L0": 1582, + "ObjDataGyro_L1": 1583, + "ObjDataGyro_L2": 1584, + "ObjDataGyro_L3": 1585, + "ObjDataGyro_L4": 1586, + "ObjDataGyro_L5": 1587, + "ObjDataGyro_L6": 1588, + "ObjDataGyro_L7": 1589, + "ObjDataShrub1": 1590, + "ObjDataShrub2": 1591, + "ObjDataShrub3": 1592, + "ObjDataShrub4": 1593, + "ObjDataShrub5": 1594, + "ObjDataShrub6": 1595, + "ObjDataShrub7": 1596, + "ObjDataShrub8": 1597, + "ObjDataNick_test": 1598, + "ObjDataW_story1_hang": 1599, + "ObjDataSMW_house5": 1600, + "ObjDataSMW_house6": 1601, + "ObjDataLight": 1602, + "ObjDatapiranha": 1603, + "ObjDataPtree_bob_busted": 1604, + "ObjDataGuard_center": 1605, + "ObjDataW_story1_ramp_1": 1606, + "ObjDataW_story1_ramp_2": 1607, + "ObjDataW_story1_ramp_3": 1608, + "ObjDataW_story1_ramp_4": 1609, + "ObjDataW_story1_rock_1": 1610, + "ObjDataW_story1_rock_2": 1611, + "ObjDataW_story1_rock_3": 1612, + "ObjDataBW_gate_swing": 1613, + "ObjDataEFX_blur": 1614, + "ObjDataSphere_coll": 1615, + "ObjDataKabuto_shield": 1616, + "ObjDataMU_MPselect": 1617, + "ObjDataefx_menu": 1618, + "ObjDataBW_drawbridge": 1619, + "ObjDataBW_fence": 1620, + "ObjDataBW_prison": 1621, + "ObjDatafun_house_int": 1622, + "ObjDataMU_IDselect": 1623, + "ObjDataMU_WDselect": 1624, + "ObjDataMU_GNselect": 1625, + "ObjDataMCtower": 1626, + "ObjDatashrub9": 1627, + "ObjDatashrub10": 1628, + "ObjDatashrub11": 1629, + "ObjDatashrub12": 1630, + "ObjDatashrub13": 1631, + "ObjDatashrub14": 1632, + "ObjDatashrub15": 1633, + "ObjDatashrub16": 1634, + "ObjDatashrub17": 1635, + "ObjDatashrub18": 1636, + "ObjDatashrub19": 1637, + "ObjDatashrub20": 1638, + "ObjDataMCbarrack": 1639, + "ObjDataDesert_rock_1": 1640, + "ObjDataDesert_rock_2": 1641, + "ObjDataDesert_rock_3": 1642, + "ObjDataPtree_canopy": 1643, + "ObjDataptree_canopy_L1": 1645, + "ObjDataptree_canopy_l2": 1646, + "ObjDatashrub1_l1": 1647, + "ObjDataCloud_story1": 1648, + "ObjDatarpm_snipergun": 1649, + "ObjDatarpm_bazooka": 1650, + "ObjDatarpm_jetpack": 1651, + "ObjDataGuard_Tower1": 1652, + "ObjDataGuard_tower2": 1653, + "ObjDatamarker_spline": 1654, + "ObjDatastory4": 1655, + "ObjData1sonak_4guards": 1656, + "ObjDataRpm_torch": 1657, + "ObjDataBW_drawbridge_open": 1658, + "ObjDatastory4_gate": 1659, + "ObjData1Tsonak_4guards": 1660, + "ObjData1MCsonak_4guards": 1661, + "ObjDatabw_minibarracks": 1662, + "ObjDataGuard_SAM": 1663, + "ObjDataGuard_turret": 1664, + "ObjDatabw_prisoncrater": 1665, + "ObjDatacharger_hotspot": 1666, + "ObjDataGuard_lift": 1667, + "ObjDataGuard_lift_strut": 1668, + "ObjData2x4_guards": 1669, + "ObjData2x5_guards": 1670, + "ObjData2x3_guards": 1671, + "ObjData2x2_guards": 1672, + "ObjData2x1_guards": 1673, + "ObjDataGuard_bunker": 1674, + "ObjDatasm_plate": 1675, + "ObjDataGuard_stable": 1676, + "ObjDataPOTATO": 1677, + "ObjDatarp_jetski": 1678, + "ObjDataBW_reapertower": 1679, + "ObjDatapotato_basket": 1680, + "ObjDatarpm_telescope": 1681, + "ObjDataraik_L0": 1682, + "ObjDataRaik_L1": 1683, + "ObjDataRaik_L2": 1684, + "ObjDataRaik_L3": 1685, + "ObjDataRaik_L4": 1686, + "ObjDataRaik_L5": 1687, + "ObjDataRaik_L6": 1688, + "ObjDataRaik_L7": 1689, + "ObjDataiceberg1": 1690, + "ObjDatasm_pagoda": 1691, + "ObjDatasm_pagodagong": 1692, + "ObjDatasm_pagodagate": 1693, + "ObjDataiceberg2": 1694, + "ObjDataiceberg3": 1695, + "ObjDataiceberg4": 1696, + "ObjDataiceberg_ramp": 1697, + "ObjDatamc_gun_L0": 1698, + "ObjDataice_wall": 1699, + "ObjDataMC_machinegun_L0": 1700, + "ObjDatastory5": 1701, + "ObjDataMC_shotgun_L0": 1702, + "ObjDataMC_grenade_L0": 1703, + "ObjDataMC_launcher_L0": 1704, + "ObjDataMC_mortar_L0": 1705, + "ObjDataMC_snipergun_L0": 1706, + "ObjDatasmborjoyzee_staff": 1707, + "ObjDataguard_shop": 1708, + "ObjDataStone_command": 1709, + "ObjDataguard_lift_base": 1710, + "ObjDataWood_command": 1711, + "ObjDatastory3_ridge": 1712, + "ObjDataGuard_buoy": 1713, + "ObjDataMC_gun_L3": 1714, + "ObjDataMC_shotgun_L1": 1715, + "ObjDatabuoy_spline": 1716, + "ObjDatap_jetski_homing": 1717, + "ObjDatap_jetski_missile": 1718, + "ObjDatap_jetski_turbo": 1719, + "ObjDataEFX_sunflare": 1720, + "ObjDataMC_gun_L1": 1721, + "ObjDataMC_gun_L2": 1722, + "ObjDataMC_gun_L4": 1723, + "ObjDataMC_gun_L5": 1724, + "ObjDataMC_machinegun_L1": 1725, + "ObjDataMC_machinegun_L2": 1726, + "ObjDataMC_machinegun_L3": 1727, + "ObjDataMC_machinegun_L4": 1728, + "ObjDataMC_machinegun_L5": 1729, + "ObjDataMC_mortar_L1": 1730, + "ObjDataMC_mortar_L2": 1731, + "ObjDataMC_mortar_L3": 1732, + "ObjDataMC_mortar_L4": 1733, + "ObjDataMC_mortar_L5": 1734, + "ObjDataMC_launcher_L1": 1735, + "ObjDataMC_launcher_L2": 1736, + "ObjDataMC_launcher_L3": 1737, + "ObjDataMC_launcher_L4": 1738, + "ObjDataMC_launcher_L5": 1739, + "ObjDataMC_shotgun_L2": 1740, + "ObjDataMC_shotgun_L3": 1741, + "ObjDataMC_shotgun_L4": 1742, + "ObjDataMC_shotgun_L5": 1743, + "ObjDataMC_snipergun_L1": 1744, + "ObjDataMC_snipergun_L2": 1745, + "ObjDataMC_snipergun_L3": 1746, + "ObjDataMC_snipergun_L4": 1747, + "ObjDataMC_snipergun_L5": 1748, + "ObjDatarpm_telescope_L1": 1749, + "ObjDatarpm_telescope_L2": 1750, + "ObjDatarpm_telescope_L3": 1751, + "ObjDatarpm_telescope_L4": 1752, + "ObjDataBW_prison_L1": 1753, + "ObjDataBW_prison_L2": 1754, + "ObjDataBW_prison_L3": 1755, + "ObjDataRpm_Spear_L1": 1756, + "ObjDataRpm_Spear_L2": 1757, + "ObjDataRpm_Spear_L3": 1758, + "ObjDataRpm_Spear_L4": 1759, + "ObjDataRpm_snipergun_L1": 1760, + "ObjDataRpm_snipergun_L3": 1761, + "ObjDataRpm_snipergun_L2": 1762, + "ObjDataRpm_snipergun_L4": 1763, + "ObjDataRpm_bazooka_L1": 1764, + "ObjDataRpm_bazooka_L2": 1765, + "ObjDataRpm_bazooka_L3": 1766, + "ObjDataRpm_bazooka_L4": 1767, + "ObjDataRpm_jetpack_L1": 1768, + "ObjDataRpm_jetpack_L2": 1769, + "ObjDataRpm_jetpack_L3": 1770, + "ObjDataRpm_jetpack_L4": 1771, + "ObjDatarp_grenade_test": 1772, + "ObjDataRpman_Grenade_L1": 1773, + "ObjDataRpm_Horn_L2": 1774, + "ObjDataRpm_Horn_L1": 1775, + "ObjDataRpm_Horn_L3": 1776, + "ObjDataRpm_Horn_L4": 1777, + "ObjDataRpman_Tuba_L1": 1778, + "ObjDataRpman_Tuba_L2": 1779, + "ObjDataRpman_Tuba_L3": 1780, + "ObjDataRpman_Tuba_L4": 1781, + "ObjDataBW_reapertower_L1": 1782, + "ObjDataBW_reapertower_L2": 1783, + "ObjDataBW_reapertower_L3": 1784, + "ObjDataBW_reapertower_L4": 1785, + "ObjDataBW_reapertower_L5": 1786, + "ObjDataGuard_bunker_L1": 1787, + "ObjDataGuard_bunker_L2": 1788, + "ObjDataGuard_bunker_L3": 1789, + "ObjDataGuard_bunker_L4": 1790, + "ObjDatabw_minibarracks_L1": 1791, + "ObjDatabw_minibarracks_L2": 1792, + "ObjDatabw_minibarracks_L3": 1793, + "ObjDatabw_minibarracks_L4": 1794, + "ObjDataGuard_SAM_L1": 1795, + "ObjDataGuard_SAM_L2": 1796, + "ObjDataGuard_SAM_L3": 1797, + "ObjDataGuard_SAM_L4": 1798, + "ObjDataGuard_turret_L1": 1799, + "ObjDataGuard_turret_L2": 1800, + "ObjDataGuard_turret_L3": 1801, + "ObjDataGuard_turret_L4": 1802, + "ObjDataGuard_shop_L1": 1803, + "ObjDataGuard_shop_L2": 1804, + "ObjDataGuard_shop_L3": 1805, + "ObjDataGuard_shop_L4": 1806, + "ObjDataGuard_stable_L1": 1807, + "ObjDataGuard_stable_L2": 1808, + "ObjDataGuard_stable_L3": 1809, + "ObjDataGuard_stable_L4": 1810, + "ObjDatasm_pagoda_L1": 1811, + "ObjDatasm_pagoda_L2": 1812, + "ObjDatasm_pagoda_L3": 1813, + "ObjDatasm_pagoda_L4": 1814, + "ObjDatasm_pagodagong_L1": 1815, + "ObjDatasm_pagodagong_L2": 1816, + "ObjDatasm_pagodagong_L3": 1817, + "ObjDatasm_pagodagong_L4": 1818, + "ObjDataGuard_tower1_L1": 1819, + "ObjDataGuard_tower1_L2": 1820, + "ObjDataGuard_tower1_L3": 1821, + "ObjDataGuard_tower1_L4": 1822, + "ObjDataGuard_tower2_L1": 1823, + "ObjDataGuard_tower2_L2": 1824, + "ObjDataGuard_tower2_L3": 1825, + "ObjDataGuard_tower2_L4": 1826, + "ObjDataBW_prisoncrater_L1": 1827, + "ObjDataBW_prisoncrater_L2": 1828, + "ObjDataBW_prisoncrater_L3": 1829, + "ObjDataEFX_ref_machinegun": 1830, + "ObjDataGuard_lift_L1": 1831, + "ObjDataGuard_lift_L2": 1832, + "ObjDataGuard_lift_L3": 1833, + "ObjDataGuard_lift_L4": 1834, + "ObjDataGuard_lift_base_L1": 1835, + "ObjDataGuard_lift_base_L2": 1836, + "ObjDataGuard_lift_base_L3": 1837, + "ObjDataGuard_lift_base_L4": 1838, + "ObjDataGuard_lift_strut_L1": 1839, + "ObjDataGuard_lift_strut_L2": 1840, + "ObjDataGuard_lift_strut_L3": 1841, + "ObjDataGuard_lift_strut_L4": 1842, + "ObjDataEFX_sniper_flash2": 1843, + "ObjDatamc1_arm_base": 1844, + "ObjDataEFX_smoke_ring": 1845, + "ObjDataEFX_ref_vert_circle": 1846, + "ObjDatakentestobject": 1847, + "ObjDataEFX_shotgun_blast": 1848, + "ObjDataEFX_ripper_Lspit": 1849, + "ObjDataEFX_ripper_Mspit": 1850, + "ObjDataMC_shotgun_shell": 1851, + "ObjData1Tsonak": 1852, + "ObjDatarpman_sonak_shell": 1853, + "ObjDataVimpfoodchunk1": 1854, + "ObjDataVimpfoodchunk2": 1855, + "ObjDataVimpfoodchunk3": 1856, + "ObjDataEFX_sam_debri": 1857, + "ObjDataEFX_ref_sam_explode": 1858, + "ObjDataEFX_ref_turret_explode": 1859, + "ObjDatamc_pickup_mines": 1860, + "ObjDataEFX_turret_debri": 1861, + "ObjDataEFX_smoke_ring_white": 1862, + "ObjDataGiants_logo_3D": 1863, + "ObjDataGuard_tower1D": 1864, + "ObjDataGuard_tower1D_L1": 1865, + "ObjDataGuard_tower1D_L2": 1866, + "ObjDataGuard_tower1D_L3": 1867, + "ObjDataGuard_buoy_L1": 1868, + "ObjDataGuard_buoy_L2": 1869, + "ObjDataGuard_buoy_L3": 1870, + "ObjDataGuard_buoy_L4": 1871, + "ObjDataGuard_bunkerD_L1": 1872, + "ObjDataGuard_bunkerD_L2": 1873, + "ObjDataGuard_bunkerD_L3": 1874, + "ObjDataGuard_bunkerD_L4": 1875, + "ObjDataGuard_bunkerD": 1876, + "ObjDataGuard_tower2D": 1877, + "ObjDataGuard_tower2D_L1": 1878, + "ObjDataGuard_tower2D_L2": 1879, + "ObjDataGuard_tower2D_L3": 1880, + "ObjDataEFX_sunflare2": 1881, + "ObjDataefx_kentestobj1": 1882, + "ObjDataefx_kentestobj2": 1883, + "ObjDataefx_kentestobj3": 1884, + "ObjDataEFX_stable_debri_2": 1885, + "ObjDataEFX_stable_debri_1": 1886, + "ObjDataEFX_stable_debri_3": 1887, + "ObjDataEFX_stable_debri_4": 1888, + "ObjDataGuard_stableD": 1889, + "ObjDataEFX_sun_orange": 1890, + "ObjDataScreens_Video": 1891, + "ObjDataScreens_Audio": 1892, + "ObjDataScreens_Exit": 1893, + "ObjDataScreens_game_options": 1894, + "ObjDataEFX_guard_tower2": 1895, + "ObjDataEFX_guard_tower_debri": 1896, + "ObjDataefx_smoke_green": 1897, + "ObjDataScreens_menu_icons": 1898, + "ObjDataRP1_arm_base": 1899, + "ObjDataScreens_Keys_Mecc": 1900, + "ObjDataScreens_Keys_Reaper": 1901, + "ObjDataScreens_Keys_Kabuto": 1902, + "ObjDataPtree_bob_coll": 1903, + "ObjDatarp_bow": 1904, + "ObjDatarp_bow_L1": 1905, + "ObjDatarp_bow_L2": 1906, + "ObjDatarp_bow_L3": 1907, + "ObjDatarp_bow_L4": 1908, + "ObjDatarp_bow_L5": 1909, + "ObjDatarp_sword_L1": 1910, + "ObjDatarp_sword_L2": 1911, + "ObjDatarp_sword_L3": 1912, + "ObjDatarp_sword_L4": 1913, + "ObjDatarp_sword_L5": 1914, + "ObjDatarp_bow_rpg_L1": 1915, + "ObjDatarp_bow_rpg_L2": 1916, + "ObjDatarp_bow_rpg_L3": 1917, + "ObjDatarp_bow_rpg_L4": 1918, + "ObjDatarp_bow_rpg_L5": 1919, + "ObjDataEFX_MC_lbomb": 1920, + "ObjDataRstory4": 1921, + "ObjDatarp_bow_sniper_L1": 1922, + "ObjDatarp_bow_sniper_L2": 1923, + "ObjDatarp_bow_sniper_L3": 1924, + "ObjDatarp_bow_sniper_L4": 1925, + "ObjDatarp_bow_sniper_L5": 1926, + "ObjDatarp_bow_homing_L1": 1927, + "ObjDatarp_bow_homing_L2": 1928, + "ObjDatarp_bow_homing_L3": 1929, + "ObjDatarp_bow_homing_L4": 1930, + "ObjDatarp_bow_homing_L5": 1931, + "ObjDataR3_start_finish": 1932, + "ObjDatamagic_wall1": 1933, + "ObjDatamagic_wall2": 1934, + "ObjDatamagic_gate1": 1935, + "ObjDatamagic_gate2": 1936, + "ObjDatarp_workshop": 1937, + "ObjDatad_rp_workshop": 1938, + "ObjDatarp_generator": 1939, + "ObjDatad_rp_generator": 1940, + "ObjDatarp_fun_house": 1941, + "ObjDatad_rp_fun_house": 1942, + "ObjDatarp_command": 1943, + "ObjDatarpm_jetski": 1944, + "ObjDataR3_lap_marker": 1945, + "ObjDataGuard_army_barracks": 1946, + "ObjDataarmy_spline": 1947, + "ObjDatapebble": 1948, + "ObjDataWood_shop_L1": 1949, + "ObjDataWood_shop_L2": 1950, + "ObjDataWood_shop_L3": 1951, + "ObjDataWood_shop_L4": 1952, + "ObjDataWood_shop_L5": 1953, + "ObjDataWood_shop_L6": 1954, + "ObjDataWood_gift_L1": 1955, + "ObjDataWood_gift_L2": 1956, + "ObjDataWood_gift_L3": 1957, + "ObjDataWood_gift_L4": 1958, + "ObjDataWood_gift_L5": 1959, + "ObjDataWood_gift_L6": 1960, + "ObjDatastone_gift_L1": 1961, + "ObjDatastone_gift_L2": 1962, + "ObjDatastone_gift_L3": 1963, + "ObjDatastone_gift_L4": 1964, + "ObjDatastone_gift_L5": 1965, + "ObjDatastone_gift_L6": 1966, + "ObjDatastone_shop_L1": 1967, + "ObjDatastone_shop_L2": 1968, + "ObjDatastone_shop_L3": 1969, + "ObjDatastone_shop_L4": 1970, + "ObjDatastone_shop_L5": 1971, + "ObjDatastone_shop_L6": 1972, + "ObjDataStatus_Kabuto": 1973, + "ObjDataR_grid": 1974, + "ObjDataEFX_Rstory5_volcano": 1975, + "ObjDataRstory5_cave": 1976, + "ObjDatabw_giantwall": 1977, + "ObjDataGuard_Army_barracks_L1": 1978, + "ObjDataGuard_Army_barracks_L2": 1979, + "ObjDataGuard_Army_barracks_L3": 1980, + "ObjDataGuard_Army_barracks_L4": 1981, + "ObjDataGuard_Army_barracks_L5": 1982, + "ObjDataGuard_Army_barracks_L6": 1983, + "ObjDataToby": 1984, + "ObjDataStatus_jetski": 1985, + "ObjDatastory4_door": 1986, + "ObjDatascreens_video_res": 1987, + "ObjDataEFX_ice_wall_debri": 1988, + "ObjDataReaper_ship": 1989, + "ObjDataReaper_ship_husk": 1990, + "ObjDataGuard_army_barracks_husk": 1991, + "ObjData7_flying_guards": 1992, + "ObjDatamag_crystal": 1993, + "ObjData1_ripper": 1994, + "ObjData2_rippers": 1995, + "ObjData3_rippers": 1996, + "ObjData1_sniper": 1997, + "ObjData1_kamikazi": 1998, + "ObjDatas_reaper_pier": 1999, + "ObjDatascreens_game_types": 2003, + "ObjDatas_mecc_sam": 2004, + "ObjDatas_mecc_turret": 2005, + "ObjDatas_reaper_turret": 2006, + "ObjDatas_reaper_sam": 2007, + "ObjDatas_reaper_tower": 2008, + "ObjDatabarracks_L1": 2009, + "ObjDatabarracks_L2": 2010, + "ObjDatabarracks_L3": 2011, + "ObjDatabarracks_L4": 2012, + "ObjDatabarracks_L5": 2013, + "ObjDatabarracks_husk": 2014, + "ObjDatastatus_mecc": 2015, + "ObjDatabump_test": 2016, + "ObjDatas_reaper_portal": 2017, + "ObjDatamother_ship": 2023, + "ObjDatamag_crystal_shard": 2024, + "ObjDatayan_sword": 2025, + "ObjDatayan_sword_L1": 2026, + "ObjDatayan_sword_L2": 2027, + "ObjDatayan_sword_L3": 2028, + "ObjDatamc_cutout1": 2029, + "ObjDatamc_cutout2": 2030, + "ObjDatarpm_bomb": 2031, + "ObjDatakabuto_stone": 2032, + "ObjDataefx_portal": 2033, + "ObjDatarpm_bomb_L1": 2034, + "ObjDatarpm_bomb_L2": 2035, + "ObjDatarpm_bomb_L3": 2036, + "ObjDatarpm_bomb_L4": 2037, + "ObjDataEFX_mc_rocket": 2038, + "ObjDatagiantwall1": 2039, + "ObjDatagiantwall2": 2040, + "ObjDatagiantwall3": 2041, + "ObjDatakab_ash": 2042, + "ObjDataGuard_portal": 2043, + "ObjDatasm_timmygrave": 2044, + "ObjDataGuard_portal_M": 2045, + "ObjDatagiantwall1_L1": 2046, + "ObjDatagiantwall1_L2": 2047, + "ObjDatagiantwall1_L3": 2048, + "ObjDatagiantwall1_L4": 2049, + "ObjDatagiantwall2_L1": 2050, + "ObjDatagiantwall2_L2": 2051, + "ObjDatagiantwall2_L3": 2052, + "ObjDatagiantwall2_L4": 2053, + "ObjDataReaper_Galleon": 2054, + "ObjDataK_rock_gen": 2055, + "ObjDataK_pocket": 2056, + "ObjDatasmdoomed_l0": 2057, + "ObjDatasmd_ground": 2058, + "ObjData5_flying_guards": 2059, + "ObjData3_flying_guards": 2060, + "ObjDataEFX_portal_charm": 2061, + "ObjDataRP_mine": 2062, + "ObjDataRP_pickup_mines": 2063, + "ObjDataRP_health": 2064, + "ObjDataRP_pickup_health": 2065, + "ObjDataFun_house_L1": 2066, + "ObjDataFun_house_L2": 2067, + "ObjDataFun_house_L3": 2068, + "ObjDataFun_house_L4": 2069, + "ObjDataFun_house_L5": 2070, + "ObjDataFun_house_L6": 2071, + "ObjDatastatus_reaper": 2072, + "ObjDataD_stone_shop_L1": 2073, + "ObjDataD_stone_shop_L2": 2074, + "ObjDataD_stone_shop_L3": 2075, + "ObjDataD_stone_shop_L4": 2076, + "ObjDataD_wood_shop_L1": 2077, + "ObjDataD_wood_shop_L2": 2078, + "ObjDataD_wood_shop_L3": 2079, + "ObjDataD_wood_shop_L4": 2080, + "ObjDataD_fun_house_L1": 2081, + "ObjDataD_fun_house_L2": 2082, + "ObjDataD_fun_house_L3": 2083, + "ObjDataD_fun_house_L4": 2084, + "ObjDataD_wood_gift_L1": 2085, + "ObjDataD_wood_gift_L2": 2086, + "ObjDataD_wood_gift_L3": 2087, + "ObjDataD_wood_gift_L4": 2088, + "ObjDataD_stone_gift_L1": 2089, + "ObjDataD_stone_gift_L2": 2090, + "ObjDataD_stone_gift_L3": 2091, + "ObjDataD_stone_gift_L4": 2092, + "ObjDatas_mecc_SAM_L1": 2093, + "ObjDatas_mecc_SAM_L2": 2094, + "ObjDatas_mecc_SAM_L3": 2095, + "ObjDatas_mecc_SAM_L4": 2096, + "ObjDatas_mecc_SAM_L5": 2097, + "ObjDatas_mecc_SAM_L6": 2098, + "ObjDatas_mecc_turret_L1": 2099, + "ObjDatas_mecc_turret_L2": 2100, + "ObjDatas_mecc_turret_L3": 2101, + "ObjDatas_mecc_turret_L4": 2102, + "ObjDatas_mecc_turret_L5": 2103, + "ObjDatas_mecc_turret_L6": 2104, + "ObjDataWood_pub_L1": 2105, + "ObjDataWood_pub_L2": 2106, + "ObjDataWood_pub_L3": 2107, + "ObjDataWood_pub_L4": 2108, + "ObjDataWood_pub_L5": 2109, + "ObjDataWood_pub_L6": 2110, + "ObjDataD_wood_pub_L1": 2111, + "ObjDataD_wood_pub_L3": 2112, + "ObjDataD_wood_pub_L2": 2113, + "ObjDataD_wood_pub_L4": 2114, + "ObjDataWood_gate_L1": 2115, + "ObjDataWood_gate_L2": 2116, + "ObjDataWood_gate_L3": 2117, + "ObjDatad_wood_wall_L1": 2118, + "ObjDatad_wood_wall_L2": 2119, + "ObjDataWood_wall_L1": 2120, + "ObjDataWood_wall_L2": 2121, + "ObjDataWood_wall_L3": 2122, + "ObjDataWood_gate_L4": 2123, + "ObjDataD_Wood_gate_L1": 2124, + "ObjDataD_Wood_gate_L2": 2125, + "ObjDataStone_wall_L1": 2126, + "ObjDataStone_wall_L2": 2127, + "ObjDataStone_wall_L3": 2128, + "ObjDataStone_wall_L4": 2129, + "ObjDataD_Stone_wall_L1": 2130, + "ObjDataD_Stone_wall_L2": 2131, + "ObjDataD_Stone_gate_L1": 2132, + "ObjDataD_Stone_gate_L2": 2133, + "ObjDataStone_gate_L1": 2134, + "ObjDataStone_gate_L2": 2135, + "ObjDataStone_gate_L3": 2136, + "ObjDataStone_gate_L4": 2137, + "ObjDatawood_command_coll": 2138, + "ObjDatastone_command_coll": 2139, + "ObjDataguard_ripperbarracks": 2140, + "ObjDatad_extractor_2_coll": 2141, + "ObjDataD_magic_wall1": 2142, + "ObjDataD_magic_wall2": 2143, + "ObjDataD_magic_gate1": 2144, + "ObjDataD_magic_gate2": 2145, + "ObjDatad_ext2_coll": 2146, + "ObjDataRP_pickup_repair": 2147, + "ObjDataW_story1_walls": 2148, + "ObjDataw_story1_arch": 2149, + "ObjDataw_story1_entrance": 2150, + "ObjDatad_stone_command": 2151, + "ObjDatad_rp_command": 2152, + "ObjDataRP_workshop_L1": 2153, + "ObjDataRP_workshop_L2": 2154, + "ObjDataRP_workshop_L3": 2155, + "ObjDataRP_workshop_L4": 2156, + "ObjDataRP_workshop_L5": 2157, + "ObjDataRP_workshop_L6": 2158, + "ObjDataD_RP_workshop_L1": 2159, + "ObjDataD_RP_workshop_L2": 2160, + "ObjDataD_RP_workshop_L3": 2161, + "ObjDataD_RP_workshop_L4": 2162, + "ObjDataRP_generator_L1": 2163, + "ObjDataRP_generator_L2": 2164, + "ObjDataRP_generator_L3": 2165, + "ObjDataRP_generator_L4": 2166, + "ObjDataRP_generator_L5": 2167, + "ObjDataRP_generator_L6": 2168, + "ObjDataD_RP_generator_L1": 2169, + "ObjDataD_RP_generator_L2": 2170, + "ObjDataD_RP_generator_L3": 2171, + "ObjDataD_RP_generator_L4": 2172, + "ObjDataD_RP_Fun_house_L1": 2173, + "ObjDataD_RP_Fun_house_L2": 2174, + "ObjDataD_RP_Fun_house_L3": 2175, + "ObjDataD_RP_Fun_house_L4": 2176, + "ObjDataRP_Fun_house_L1": 2177, + "ObjDataRP_Fun_house_L2": 2178, + "ObjDataRP_Fun_house_L3": 2179, + "ObjDataRP_Fun_house_L4": 2180, + "ObjDataRP_Fun_house_L5": 2181, + "ObjDataRP_Fun_house_L6": 2182, + "ObjDatad_spellshop_1_L1": 2183, + "ObjDatad_spellshop_1_L2": 2184, + "ObjDatad_spellshop_1_L3": 2185, + "ObjDatad_spellshop_1_L4": 2186, + "ObjDataspellshop_1_L1": 2187, + "ObjDataspellshop_1_L2": 2188, + "ObjDataspellshop_1_L3": 2189, + "ObjDataspellshop_1_L4": 2190, + "ObjDataspellshop_1_L5": 2191, + "ObjDataspellshop_1_L6": 2192, + "ObjDataspellshop_2_L1": 2193, + "ObjDataspellshop_2_L2": 2194, + "ObjDataspellshop_2_L3": 2195, + "ObjDataspellshop_2_L4": 2196, + "ObjDataspellshop_2_L5": 2197, + "ObjDataspellshop_2_L6": 2198, + "ObjDatad_spellshop_2_L1": 2199, + "ObjDatad_spellshop_2_L2": 2200, + "ObjDatad_spellshop_2_L3": 2201, + "ObjDatad_spellshop_2_L4": 2202, + "ObjDatad_Extractor_2_L1": 2203, + "ObjDatad_Extractor_2_L2": 2204, + "ObjDatad_Extractor_2_L3": 2205, + "ObjDatad_Extractor_2_L4": 2206, + "ObjDataExtractor_2_L1": 2207, + "ObjDataExtractor_2_L2": 2208, + "ObjDataExtractor_2_L3": 2209, + "ObjDataExtractor_2_L4": 2210, + "ObjDataExtractor_2_L5": 2211, + "ObjDataExtractor_2_L6": 2212, + "ObjDatamagic_wall1_L1": 2213, + "ObjDatamagic_wall1_L2": 2214, + "ObjDatamagic_wall1_L3": 2215, + "ObjDatamagic_wall1_L4": 2216, + "ObjDatamagic_wall1_L5": 2217, + "ObjDatamagic_wall1_L6": 2218, + "ObjDataD_Magic_wall1_L1": 2219, + "ObjDataD_Magic_wall1_L2": 2220, + "ObjDataD_Magic_wall1_L3": 2221, + "ObjDataD_Magic_wall1_L4": 2222, + "ObjDataD_Magic_wall2_L1": 2223, + "ObjDataD_Magic_wall2_L2": 2224, + "ObjDataD_Magic_wall2_L3": 2225, + "ObjDataD_Magic_wall2_L4": 2226, + "ObjDataMagic_wall2_L1": 2227, + "ObjDataMagic_wall2_L2": 2228, + "ObjDataMagic_wall2_L3": 2229, + "ObjDataMagic_wall2_L4": 2230, + "ObjDataMagic_wall2_L5": 2231, + "ObjDataMagic_wall2_L6": 2232, + "ObjDataReg_kiss": 2233, + "ObjDatas_mecc_tower_L1": 2234, + "ObjDatas_mecc_tower_L2": 2235, + "ObjDatas_mecc_tower_L3": 2236, + "ObjDatas_mecc_tower_L4": 2237, + "ObjDatas_mecc_tower_L5": 2238, + "ObjDatas_mecc_tower_L6": 2239, + "ObjDatas_mecc_shop_L1": 2240, + "ObjDatas_mecc_shop_L2": 2241, + "ObjDatas_mecc_shop_L3": 2242, + "ObjDatas_mecc_shop_L4": 2243, + "ObjDatas_mecc_shop_L5": 2244, + "ObjDatas_mecc_shop_L6": 2245, + "ObjDatas_mecc_gpad_L3": 2246, + "ObjDatas_mecc_gpad_L2": 2247, + "ObjDatas_mecc_gpad_L1": 2248, + "ObjDatas_mecc_teleport_L1": 2249, + "ObjDatas_mecc_teleport_L2": 2250, + "ObjDatas_mecc_teleport_L3": 2251, + "ObjDatas_mecc_bunker_L1": 2252, + "ObjDatas_mecc_bunker_L2": 2253, + "ObjDatas_mecc_bunker_L3": 2254, + "ObjDatas_reaper_turret_L1": 2255, + "ObjDatas_reaper_turret_L2": 2256, + "ObjDatas_reaper_turret_L3": 2257, + "ObjDatas_reaper_turret_L4": 2258, + "ObjDatas_reaper_turret_L5": 2259, + "ObjDatas_reaper_turret_L6": 2260, + "ObjDataExtractor_1_L1": 2261, + "ObjDataExtractor_1_L2": 2262, + "ObjDataExtractor_1_L3": 2263, + "ObjDataExtractor_1_L4": 2264, + "ObjDataExtractor_1_L5": 2265, + "ObjDataExtractor_1_L6": 2266, + "ObjDatas_reaper_SAM_L1": 2267, + "ObjDatas_reaper_SAM_L2": 2268, + "ObjDatas_reaper_SAM_L3": 2269, + "ObjDatas_reaper_SAM_L4": 2270, + "ObjDatas_reaper_SAM_L5": 2271, + "ObjDatas_reaper_SAM_L6": 2272, + "ObjDatas_reaper_tower_L1": 2273, + "ObjDatas_reaper_tower_L2": 2274, + "ObjDatas_reaper_tower_L3": 2275, + "ObjDatas_reaper_tower_L4": 2276, + "ObjDatas_reaper_tower_L5": 2277, + "ObjDatas_reaper_tower_L6": 2278, + "ObjDatas_reaper_shop_L1": 2279, + "ObjDatas_reaper_shop_L2": 2280, + "ObjDatas_reaper_shop_L3": 2281, + "ObjDatas_reaper_shop_L4": 2282, + "ObjDatas_reaper_shop_L5": 2283, + "ObjDatas_reaper_shop_L6": 2284, + "ObjDatas_reaper_pier_L1": 2285, + "ObjDatas_reaper_pier_L2": 2286, + "ObjDatas_reaper_pier_L3": 2287, + "ObjDatas_reaper_pier_L4": 2288, + "ObjDatas_reaper_pier_L5": 2289, + "ObjDatas_reaper_pier_L6": 2290, + "ObjDataRP_command_L1": 2291, + "ObjDataRP_command_L2": 2292, + "ObjDataRP_command_L3": 2293, + "ObjDataRP_command_L4": 2294, + "ObjDataRP_command_L5": 2295, + "ObjDataRP_command_L6": 2296, + "ObjDataD_RP_command_L1": 2297, + "ObjDataD_RP_command_L2": 2298, + "ObjDataD_RP_command_L3": 2299, + "ObjDataD_RP_command_L4": 2300, + "ObjDatastone_command_L1": 2301, + "ObjDatastone_command_L2": 2302, + "ObjDatastone_command_L3": 2303, + "ObjDatastone_command_L4": 2304, + "ObjDatastone_command_L5": 2305, + "ObjDatastone_command_L6": 2306, + "ObjDataD_stone_command_L1": 2307, + "ObjDataD_stone_command_L2": 2308, + "ObjDataD_stone_command_L3": 2309, + "ObjDataD_stone_command_L4": 2310, + "ObjDataK_lava_ball": 2311, + "ObjDataK_volcano_debri": 2312, + "ObjDataK_exhaust": 2313, + "ObjDataEFX_repair_ring": 2314, + "ObjDataK_rock_gen_top": 2315, + "ObjDataw_story1_mine": 2316, + "ObjDataw_story1_walls_1": 2317, + "ObjDataw_story1_walls_2": 2318, + "ObjDataw_story1_walls_3": 2319, + "ObjDataw_story1_walls_4": 2320, + "ObjDataw_story1_walls_5": 2321, + "ObjDataw_story1_walls_6": 2322, + "ObjDataCharger_snow": 2323, + "ObjDataEFX_magic_W1": 2324, + "ObjDataEFX_portal_open_loop": 2325, + "ObjDataEFX_portal_open_flick": 2326, + "ObjDataEFX_portal_close_flick": 2327, + "ObjDataw_story1_hang_flick": 2328, + "ObjDatashrub5_coll": 2343, + "ObjDataRipper_radius": 2344, + "ObjDataBarracks_story2": 2345, + "ObjDatagiantwall3_L1": 2346, + "ObjDatagiantwall3_L2": 2347, + "ObjDatagiantwall3_L3": 2348, + "ObjDatagiantwall3_L4": 2349, + "ObjDatagiantwall4": 2350, + "ObjDataShrub5_L1": 2352, + "ObjDataShrub5_L2": 2353, + "ObjDataShrub5_L3": 2354, + "ObjDataShrub6_L1": 2355, + "ObjDataShrub6_L2": 2356, + "ObjDataShrub6_L3": 2357, + "ObjDatashrub7_L1": 2358, + "ObjDatashrub7_L2": 2359, + "ObjDatashrub7_L3": 2360, + "ObjDatashrub8_L1": 2361, + "ObjDatashrub8_L2": 2362, + "ObjDatashrub8_L3": 2363, + "ObjDatashrub9_L1": 2364, + "ObjDatashrub9_L2": 2365, + "ObjDatashrub9_L3": 2366, + "ObjDatashrub10_L1": 2367, + "ObjDatashrub10_L2": 2368, + "ObjDataA_M1_near_beach": 2369, + "ObjDataA_M2_mnt_beach": 2370, + "ObjDataA_M3_cliffs_sand": 2371, + "ObjDataA_M4_beach_dark": 2372, + "ObjDataA_M5_beach_waves": 2373, + "ObjDataA_R1_light_rain": 2374, + "ObjDataA_R2_snow": 2375, + "ObjDataA_R3_race": 2376, + "ObjDataA_R4_darker": 2377, + "ObjDataA_R5_mountain": 2378, + "ObjDataA_K1": 2379, + "ObjDataA_K5_storm": 2380, + "ObjDataA_crashed_lander": 2381, + "ObjDataA_floating_gate": 2383, + "ObjDataA_cage": 2385, + "ObjDataA_distant_birds": 2386, + "ObjDataA_wind_gusts": 2387, + "ObjDataA_single_tree": 2388, + "ObjDataA_trees": 2389, + "ObjDataA_shoreline": 2390, + "ObjDataA_pools": 2391, + "ObjDataA_pier": 2392, + "ObjDataA_big_leaf_tree": 2393, + "ObjDataA_reaper_tower": 2394, + "ObjDataA_int_volcano": 2395, + "ObjDataA_Smartie_village": 2396, + "ObjDataA_high_village": 2397, + "ObjDataA_high_winds": 2398, + "ObjDataA_prison": 2399, + "ObjDataA_army_barracks": 2400, + "ObjDataA_forest_trees": 2402, + "ObjDataA_distant_animals": 2403, + "ObjData4_wide_guards": 2404, + "ObjDatasmf_L1": 2405, + "ObjDatasmf_L2": 2406, + "ObjDatasmf_L3": 2407, + "ObjDatasmf_L4": 2408, + "ObjDatasmf_L5": 2409, + "ObjDatasmf_L6": 2410, + "ObjDataA_shoreline_long": 2411, + "ObjDataA_shoreline_dark_short": 2412, + "ObjDataA_shoreline_dark_long": 2413, + "ObjDataA_river": 2414, + "ObjDataA_high_winds_light": 2415, + "ObjDataA_cold_wind_gusts": 2416, + "ObjDataA_cold_winds_gusts": 2417, + "ObjDataEFX_giantwall4": 2418, + "ObjDataA_kabuto_temp": 2419, + "ObjDataA_mecc_temp": 2420, + "ObjDataA_mecc_temp_amb": 2421, + "ObjDataA_mecc_temp_battle": 2422, + "ObjDataA_mecc_temp_sus": 2423, + "ObjDatastory4_tower": 2424, + "ObjDatastory4_tower_coll": 2425, + "ObjDatastory4_tower_L1": 2426, + "ObjDatastory4_tower_L2": 2427, + "ObjDatastory4_tower_L3": 2428, + "ObjDatastory4_tower_L4": 2429, + "ObjDatastory4_tower_L5": 2430, + "ObjDatagiantwall4_L1": 2431, + "ObjDatagiantwall4_L2": 2432, + "ObjDatagiantwall4_L3": 2433, + "ObjDatagiantwall4_L4": 2434, + "ObjDataMCBarrack_L1": 2435, + "ObjDataMCBarrack_L2": 2436, + "ObjDataMCBarrack_L3": 2437, + "ObjDataMCBarrack_L4": 2438, + "ObjDataMCBarrack_L5": 2439, + "ObjDataMCBarrack_L6": 2440, + "ObjDataMC_turret_L1": 2441, + "ObjDataMC_turret_L3": 2442, + "ObjDataMC_turret_L4": 2443, + "ObjDataMC_Mine_L1": 2444, + "ObjDataMC_Mine_L2": 2445, + "ObjDataMC_Mine_L3": 2446, + "ObjDataMC_Mine_L4": 2447, + "ObjDatasmW_house6_L1": 2448, + "ObjDatasmW_house6_L2": 2449, + "ObjDatasmW_house6_L3": 2450, + "ObjDatasmW_house6_L4": 2451, + "ObjDatasmW_house5_L1": 2452, + "ObjDatasmW_house5_L2": 2453, + "ObjDatasmW_house5_L3": 2454, + "ObjDatasmW_house5_L4": 2455, + "ObjDatasmW_house4_L1": 2456, + "ObjDatasmW_house4_L2": 2457, + "ObjDatasmW_house4_L3": 2458, + "ObjDatasmW_house4_L4": 2459, + "ObjDatasmf_healthy_L0": 2460, + "ObjDatasmf_healthy_L1": 2461, + "ObjDatasmf_healthy_L2": 2462, + "ObjDatasmf_healthy_L3": 2463, + "ObjDatasmf_healthy_L4": 2464, + "ObjDatasmf_healthy_L5": 2465, + "ObjDatasmf_healthy_L6": 2466, + "ObjDatasmf_healthy_L7": 2467, + "ObjDatasmW_house3_L1": 2468, + "ObjDatasmW_house3_L2": 2469, + "ObjDatasmW_house3_L3": 2470, + "ObjDatasmW_house3_L4": 2471, + "ObjDatasmW_house2_L1": 2472, + "ObjDatasmW_house2_L2": 2473, + "ObjDatasmW_house2_L3": 2474, + "ObjDatasmW_house2_L4": 2475, + "ObjDatasmW_house1_L1": 2476, + "ObjDatasmW_house1_L2": 2477, + "ObjDatasmW_house1_L3": 2478, + "ObjDatasmW_house1_L4": 2479, + "ObjDatasm_borj_house_L1": 2480, + "ObjDatasm_borj_house_L2": 2481, + "ObjDatasm_borj_house_L3": 2482, + "ObjDatasm_borj_house_L4": 2483, + "ObjDatasm_borj_house_L5": 2484, + "ObjDatasm_borj_house_L6": 2485, + "ObjDataGuard_buoy_coll": 2486, + "ObjDatarpm_jetski_coll": 2487, + "ObjDataefx_magic_w2": 2488, + "ObjDatarp_Mine_L1": 2489, + "ObjDatarp_Mine_L2": 2490, + "ObjDatarp_Mine_L3": 2491, + "ObjDatarp_Mine_L4": 2492, + "ObjDatagiantwall5": 2493, + "ObjDatagiantwall5_L1": 2494, + "ObjDatagiantwall5_L2": 2495, + "ObjDatagiantwall5_L3": 2496, + "ObjDatagiantwall5_L4": 2497, + "ObjDatas_mecc_gpad_L4": 2498, + "ObjDatakabutopad": 2499, + "ObjDatasmW_house7": 2500, + "ObjDatasmW_house7_L1": 2501, + "ObjDatasmW_house7_L2": 2502, + "ObjDatasmW_house7_L3": 2503, + "ObjDatasmW_house7_L4": 2504, + "ObjDatasmW_house7_coll": 2505, + "ObjDatasmW_house8": 2506, + "ObjDatasmW_house8_L1": 2507, + "ObjDatasmW_house8_L2": 2508, + "ObjDatasmW_house8_L3": 2509, + "ObjDatasmW_house8_L4": 2510, + "ObjDatasmW_house8_coll": 2511, + "ObjDatasm_evil_L0": 2512, + "ObjDatasm_evil_L1": 2513, + "ObjDatasm_evil_L2": 2514, + "ObjDatasm_evil_L3": 2515, + "ObjDatasm_evil_L4": 2516, + "ObjDatasm_evil_L5": 2517, + "ObjDatasm_evil_L6": 2518, + "ObjDatasm_evil_L7": 2519, + "ObjDataA_k2": 2520, + "ObjDataA_k3": 2521, + "ObjDataA_k4": 2522, + "ObjDataA_special_tree": 2524, + "ObjDataA_pools_large": 2525, + "ObjDataA_boat": 2526, + "ObjDataSm_cart_coll": 2527, + "ObjDataWood_gate_coll": 2528, + "ObjDatamagic_wall1_coll": 2530, + "ObjDatamagic_wall2_coll": 2531, + "ObjDatasm_tower_timmy": 2532, + "ObjDatap_jetski_coll": 2533, + "ObjDataefx_magic_gate1": 2534, + "ObjDataefx_magic_gate2": 2535, + "ObjDatamagic_gate1_coll": 2536, + "ObjDatamagic_gate2_coll": 2537, + "ObjDatasm_table_dad": 2538, + "ObjDataA_Volcano": 2539, + "ObjDataKB_L1": 2540, + "ObjDatakabuto4": 2541, + "ObjDatakabuto5": 2542, + "ObjDatakabuto6": 2543, + "ObjDatakabuto7": 2544, + "ObjDatakabuto8": 2545, + "ObjDataRstory5_volcano_coll": 2546, + "ObjDataRstory5_fake": 2547, + "ObjDataFun_house_coll": 2548, + "ObjDataRP_Fun_house_coll": 2549, + "ObjDataefx_flare": 2550, + "ObjDataWood_Gift_coll": 2551, + "ObjDatastone_gift_coll": 2552, + "ObjDatas_reaper_shop_coll": 2553, + "ObjDataspellshop_1_coll": 2554, + "ObjDataspellshop_2_coll": 2555, + "ObjDataGuard_shop_coll": 2556, + "ObjDataWood_shop_coll": 2557, + "ObjDatastone_shop_coll": 2558, + "ObjDatagiantwall3_nick": 2559, + "ObjDataEFX_offspring_spit": 2560, + "ObjDataEFX_offspring_fire": 2561, + "ObjDatas_gpad_coll": 2562, + "ObjDataEFX_red_rings": 2563, + "ObjDataEFX_ref_crooked_line": 2564, + "ObjDataEFX_whizzer": 2565, + "ObjDataEFX_whizzer_sparkles": 2566, + "ObjDataEFX_deep_red": 2567, + "ObjDataSonak_coll": 2568, + "ObjDataRP_workshop_coll": 2569, + "ObjDataRP_generator_coll": 2570, + "ObjDatacharger_coll": 2571, + "ObjDataEFX_whizzer_charmL": 2572, + "ObjDataEFX_whizzer_charmR": 2573, + "ObjDataScreens_no_load": 2574, + "ObjDatas_mecc_tower_coll": 2575, + "ObjDataScreens_world_list": 2576, + "ObjDataScreens_flick_list": 2577, + "ObjDataS_mecc_teleport_coll": 2578, + "ObjDataoffspring_coll": 2579, + "ObjDataK_spike": 2580, + "ObjDataK_bridge_1": 2581, + "ObjDataK_bridge_2": 2582, + "ObjDataK_bridge_3": 2583, + "ObjDataGuard_Army_Barracks_coll": 2584, + "ObjDataBarracks_coll": 2585, + "ObjDataRM_seamonster_L1": 2586, + "ObjDataRM_seamonster_L2": 2587, + "ObjDataRM_seamonster_L3": 2588, + "ObjDataRM_seamonster_L4": 2589, + "ObjDataRM_seamonster_L5": 2590, + "ObjDataRM_seamonster_L6": 2591, + "ObjDataRM_seamonster_L7": 2592, + "ObjDatasign": 2593, + "ObjDataRM_seamonster_coll": 2594, + "ObjDataEFX_crystal_debri": 2595, + "ObjDataEFX_ref_minibarracks": 2596, + "ObjDataEFX_mini_debri_top": 2597, + "ObjDataEFX_mini_debri_1": 2598, + "ObjDataEFX_mini_debri_2": 2599, + "ObjDataEFX_mini_debri_3": 2600, + "ObjDatarp_bow_powerup_L1": 2601, + "ObjDatarp_bow_powerup_L2": 2602, + "ObjDatarp_bow_powerup_L3": 2603, + "ObjDatarp_bow_powerup_L4": 2604, + "ObjDatarp_bow_powerup_L5": 2605, + "ObjDatarp_bow_powerup_L6": 2606, + "ObjDataguard_ripperbarracks_L1": 2607, + "ObjDataguard_ripperbarracks_L2": 2608, + "ObjDataguard_ripperbarracks_L3": 2609, + "ObjDataguard_ripperbarracks_L4": 2610, + "ObjDataEFX_ref_guard_tower_1": 2611, + "ObjDataEFX_guard_tower_debri_1": 2612, + "ObjDataEFX_guard_tower_debri_2": 2613, + "ObjDataEFX_guard_tower_debri_3": 2614, + "ObjDataEFX_guard_tower_debri_4": 2615, + "ObjDataEFX_guard_tower_debri_5": 2616, + "ObjDatamap_kbo_icon": 2617, + "ObjDataEFX_ref_guard_tower_2": 2618, + "ObjDataEFX_tower_2_debri_1": 2619, + "ObjDataEFX_tower_2_debri_2": 2620, + "ObjDataEFX_tower_2_debri_3": 2621, + "ObjDataEFX_rpbarracks_debri_1": 2622, + "ObjDataEFX_rpbarracks_debri_2": 2623, + "ObjDataEFX_rpbarracks_debri_3": 2624, + "ObjDataR_grid_l0": 2625, + "ObjDataR_grid_l1": 2626, + "ObjDataR_grid_l2": 2627, + "ObjDataEFX_ref_giantwall3": 2628, + "ObjDataEFX_giantwall_debri_1": 2629, + "ObjDataEFX_giantwall_debri_2": 2630, + "ObjDataEFX_giantwall_debri_3": 2631, + "ObjDataEFX_giantwall_debri_4": 2632, + "ObjDataEFX_giantwall_debri_5": 2633, + "ObjDataEFX_giantwall_debri_6": 2634, + "ObjDataEFX_giantwall_debri_7": 2635, + "ObjDataEFX_giantwall_debri_8": 2636, + "ObjDataEFX_giantwall_debri_9": 2637, + "ObjDataEFX_giantwall_debri_10": 2638, + "ObjDataEFX_giantwall_debri_11": 2639, + "ObjDataEFX_giantwall_debri_12": 2640, + "ObjDataEFX_giantwall_debri_13": 2641, + "ObjDataEFX_giantwall_debri_14": 2642, + "ObjDataEFX_ref_giantwall5": 2643, + "ObjDataEFX_giantwall5_debri_1": 2644, + "ObjDataEFX_giantwall3_debri_s": 2645, + "ObjDataEFX_smoke_ring_b": 2646, + "ObjDataBridge_wide": 2647, + "ObjDataBW_drawbridge_coll": 2648, + "ObjDataBW_drawbridgeO_coll": 2649, + "ObjDataK_rock_gen_coll": 2650, + "ObjDataEFX_soot": 2651, + "ObjDataPatch_game_types": 2652, + "ObjDataPatch_keys_kabuto": 2653, + "ObjDataPatch_keys_reaper": 2654, + "ObjDataPatch_keys_mecc": 2655, + "ObjDataRW_circle_spell": 2656, + "ObjDataMC_nothrust_L1": 2657, + "ObjDataMC_nothrust_L2": 2658, + "ObjDataMC_nothrust_L3": 2659, + "ObjDatamc_nothrust_L0": 2660, + "ObjDataM_lander_coll": 2661, + "ObjDatabase_flag_red2": 2662, + "ObjDataEFX_dust_particle": 2663, + "ObjDataEFX_shockwave_LB": 2664, + "ObjDataEFX_emp_blast": 2665, + "ObjDataEFX_rp_Bspell_trail": 2666, + "ObjDataEFX_rp_Bspell_glow": 2667, + "ObjDataEFX_rp_Gspell_trail": 2668, + "ObjDataEFX_rp_Rspell_trail": 2669, + "ObjDataEFX_rp_Gspell_glow": 2670, + "ObjDataEFX_rp_Rspell_glow": 2671 + }, + "ObjObj": { + "ObjObjCamera": 0, + "ObjObjKabuto": 1, + "ObjObjMecc": 2, + "ObjObjReaper": 3, + "ObjObjLander": 4, + "ObjObjStation": 5, + "ObjObjBoat": 6, + "ObjObjShip": 7, + "ObjObjVimp": 8, + "ObjObjSven": 9, + "ObjObjTofo": 10, + "ObjObjSmartie": 11, + "ObjObjMC_Body": 12, + "ObjObjMCBullet": 14, + "ObjObjshawn1": 15, + "ObjObjshawn2": 16, + "ObjObjCannon": 17, + "ObjObjCannonBall": 18, + "ObjObjM_Base": 19, + "ObjObjnaked_raw": 20, + "ObjObjMCGun": 21, + "ObjObjMCShotGun": 22, + "ObjObjMCSyringe": 23, + "ObjObjRWTornado": 24, + "ObjObjmc_laser": 25, + "ObjObjK_altar": 26, + "ObjObjtest_oasis": 27, + "ObjObjMCBeamRing": 28, + "ObjObjMCLaserGun": 29, + "ObjObjRP_bow": 30, + "ObjObjRPglow": 31, + "ObjObjRW_warning": 33, + "ObjObjRParrow": 34, + "ObjObjRPfire": 35, + "ObjObjMCbush": 36, + "ObjObjRPglow2": 37, + "ObjObjmczip": 38, + "ObjObjKBtrap": 39, + "ObjObjRWTornadoF": 40, + "ObjObjMCGiant": 41, + "ObjObjMCDefaultGun": 42, + "ObjObjMCSparkle": 43, + "ObjObjEXFlash": 44, + "ObjObjEXSmokeRing": 45, + "ObjObjEXSmokeEven": 46, + "ObjObjEXSmokeOdd": 47, + "ObjObjMCSuit": 48, + "ObjObjHerdGen": 49, + "ObjObjTonguescene3": 50, + "ObjObjShawn3": 51, + "ObjObjShawn4": 52, + "ObjObjpub": 53, + "ObjObjML_hive": 54, + "ObjObjML_GuardTower": 55, + "ObjObjML_Brute": 56, + "ObjObjsm_fence": 57, + "ObjObjrockbush": 58, + "ObjObjML_Reed1": 59, + "ObjObjmc_turret": 60, + "ObjObjML_Reed2": 61, + "ObjObjML_Reed3": 62, + "ObjObjSM_trap2": 63, + "ObjObjNick_Rbush": 64, + "ObjObjShawn5": 65, + "ObjObjShawn6": 66, + "ObjObjShawn7": 67, + "ObjObjShawn8": 68, + "ObjObjShawn9": 69, + "ObjObjSm_pit": 70, + "ObjObjSm_glow": 71, + "ObjObjSmbottle": 72, + "ObjObjRipperM": 73, + "ObjObjSmoke": 74, + "ObjObjRM_seamonster": 75, + "ObjObjHideTest": 76, + "ObjObjKS_Shepherd": 77, + "ObjObjrock_1": 78, + "ObjObjrock_2": 79, + "ObjObjblueprint": 80, + "ObjObjpub_stool": 81, + "ObjObjBigRock": 82, + "ObjObjRM_jelly": 83, + "ObjObjmcthrust": 84, + "ObjObjmcthrust2": 85, + "ObjObjPier": 86, + "ObjObjN_5ftrock_1": 87, + "ObjObjqueen_spikes": 88, + "ObjObjN_20ftrock_1": 89, + "ObjObjRipSpit": 90, + "ObjObjrock_3": 91, + "ObjObjb_pod": 92, + "ObjObjb_bush": 93, + "ObjObjKS_Rock1": 94, + "ObjObjKS_Rock2": 95, + "ObjObjKS_Rock3": 96, + "ObjObjKS_SmRock1": 97, + "ObjObjKS_SmRock2": 98, + "ObjObjRipFire": 99, + "ObjObjG_Smoke": 100, + "ObjObjPtree": 101, + "ObjObjPtree_bob": 102, + "ObjObjN_bush_tall": 103, + "ObjObjN_bush_flat": 104, + "ObjObjN_bush_vtall": 105, + "ObjObjN_bush_small": 106, + "ObjObjN_tree_flat": 107, + "ObjObjTora": 108, + "ObjObjDust": 109, + "ObjObjO2_rock5": 110, + "ObjObjO2_rock8": 111, + "ObjObjO2_rock20": 112, + "ObjObjO2_rock50": 113, + "ObjObjWhipFlash": 114, + "ObjObjWhipRing": 115, + "ObjObjO1_pad": 116, + "ObjObjColl_station": 117, + "ObjObjbridge": 118, + "ObjObjsveedon": 119, + "ObjObjsveedtarget": 120, + "ObjObjwater_rings": 121, + "ObjObjFlak": 123, + "ObjObjLobird": 124, + "ObjObjb_leaf1": 125, + "ObjObjLander_static": 126, + "ObjObjMcflag": 127, + "ObjObjShiner": 128, + "ObjObjS_weeds": 129, + "ObjObjb_lilly": 130, + "ObjObjM_thudgun": 131, + "ObjObjMC_gun_rotate": 132, + "ObjObjMecc_NT": 133, + "ObjObjSquare": 134, + "ObjObjM_blueglow": 135, + "ObjObjMeccTemp": 136, + "ObjObjWater_drip": 137, + "ObjObjs_flower1": 138, + "ObjObjM_airlock1_l0": 200, + "ObjObjM_airlock2_l0": 201, + "ObjObjM_airlock3_l0": 202, + "ObjObjTir_l0": 203, + "ObjObjM_back_range": 204, + "ObjObjM_back_wake": 205, + "ObjObjM_back_mother": 206, + "ObjObjM_back_damage": 207, + "ObjObjMecc_crash1": 208, + "ObjObjSM_wall2": 209, + "ObjObjDactyl_l0": 210, + "ObjObjQ3_pillars": 211, + "ObjObjDact_nest": 212, + "ObjObjDact_temp": 213, + "ObjObjRW_cannonflash": 214, + "ObjObjRPMAN": 215, + "ObjObjSMfemale": 216, + "ObjObjDact_egg": 217, + "ObjObjRipnest": 218, + "ObjObjMound": 219, + "ObjObjDirt1": 220, + "ObjObjR_husk_damage1": 221, + "ObjObjR_husk_damage2": 222, + "ObjObjfeather1": 223, + "ObjObjRpm_Horn": 224, + "ObjObjC3_pier": 225, + "ObjObjRipnest_X": 226, + "ObjObjC3_smartiebase": 227, + "ObjObjrip_clamp_X": 228, + "ObjObjRipperS": 229, + "ObjObjRipperL": 230, + "ObjObjrip_clamp_Shell": 231, + "ObjObjRipSpitBig": 232, + "ObjObjC3_kab_wall": 233, + "ObjObjC3_sniper_tower": 234, + "ObjObjsm_fork": 235, + "ObjObjsm_knife": 236, + "ObjObjC3_gateway": 237, + "ObjObjGatedoor_l0": 238, + "ObjObjVpchunk1": 239, + "ObjObjRpm_Spear": 240, + "ObjObjRpm_Bolt": 241, + "ObjObjKab_shadow": 242, + "ObjObjC3_soon": 243, + "ObjObjSB_brick": 244, + "ObjObjSmbush": 245, + "ObjObjC3_scene_wall": 246, + "ObjObjBridge_end": 247, + "ObjObjBridge_end_coll": 248, + "ObjObjSeaport_wall": 249, + "ObjObjSM_ruins": 250, + "ObjObjM_hatch": 251, + "ObjObjM_hotfloor": 252, + "ObjObjR_husk": 253, + "ObjObjmcjetpack": 254, + "ObjObjrip_clamp": 255, + "ObjObjBridge_100ft": 256, + "ObjObjBridge_200ft": 257, + "ObjObjBridge_300ft": 258, + "ObjObjSmhouse1": 260, + "ObjObjBW_arch_100": 270, + "ObjObjBW_arch_150": 271, + "ObjObjBW_arch_200": 272, + "ObjObjBW_corner": 273, + "ObjObjBW_wall_100": 274, + "ObjObjRpm_Bullet": 275, + "ObjObjRpm_Grenade": 276, + "ObjObjSR_tower": 294, + "ObjObjSR_tower_arm": 295, + "ObjObjMCMachineGun": 300, + "ObjObjMCGrenade": 301, + "ObjObjmc_pickup_shotgun": 302, + "ObjObjmc_pickup_machinegun": 303, + "ObjObjReaperTrail1": 311, + "ObjObjrp_sword_trail": 312, + "ObjObjN_tree1": 500, + "ObjObjN_bunchoftrees": 501, + "ObjObjStream": 502, + "ObjObjWindTunnel": 503, + "ObjObjE_Wave": 504, + "ObjObjSR_tower_ring": 505, + "ObjObjsm_boat": 506, + "ObjObjsm_cart": 507, + "ObjObjsm_chimney": 508, + "ObjObjsm_dome": 509, + "ObjObjsm_domeD1": 510, + "ObjObjsm_door": 511, + "ObjObjsm_fences": 512, + "ObjObjsm_seat": 513, + "ObjObjsm_table": 514, + "ObjObjsm_tower": 515, + "ObjObjsm_well": 516, + "ObjObjsm_window": 517, + "ObjObjsm_tube": 518, + "ObjObjsm_ladder": 519, + "ObjObjsm_fences2": 520, + "ObjObjsm_post": 521, + "ObjObjsm_hatch": 522, + "ObjObjsm_Vconnect1": 523, + "ObjObjsm_Vconnect2": 524, + "ObjObjsm_sphere": 525, + "ObjObjsm_sphere2": 527, + "ObjObjbridge_400ft": 528, + "ObjObjsm_spheredark": 529, + "ObjObjsm_spheredark2": 530, + "ObjObjsm_post_tall": 531, + "ObjObjbridge_500ft": 532, + "ObjObjpier_straight": 533, + "ObjObjpier_bend90": 534, + "ObjObjpier_round_rings": 535, + "ObjObjpier_round_tile": 536, + "ObjObjpier_square": 537, + "ObjObjpier_post20": 538, + "ObjObjpier_post30": 539, + "ObjObjpier_post40": 540, + "ObjObjshadow_round": 541, + "ObjObjshadow_elipse": 542, + "ObjObjshadow_elipse2": 543, + "ObjObjsmW_entrance": 544, + "ObjObjsmW_curvehi": 545, + "ObjObjsmW_column": 546, + "ObjObjsmW_curvemed": 547, + "ObjObjsmW_curvelow": 548, + "ObjObjsmW_column2": 549, + "ObjObjsmW_cwall_low": 550, + "ObjObjsmW_wall_hi": 551, + "ObjObjsmW_wall_med": 552, + "ObjObjsmW_wall_hi_hole": 553, + "ObjObjSR_FORTLEGS": 554, + "ObjObjBW_gate_portcullis": 555, + "ObjObjBW_wall_150": 556, + "ObjObjBW_wall_200": 557, + "ObjObjBW_parapit": 558, + "ObjObjBW_sr_arch_100": 559, + "ObjObjBW_sr_corner": 560, + "ObjObjsr_mtower": 561, + "ObjObjverm": 562, + "ObjObjCanopy_1": 563, + "ObjObjbent_post": 564, + "ObjObjpier_straight_80": 565, + "ObjObjpier_straight_160": 566, + "ObjObjBW_column_20": 567, + "ObjObjBW_column_30": 568, + "ObjObjBW_column_40": 569, + "ObjObjBW_column_60": 570, + "ObjObjverm_egg": 571, + "ObjObjverm_split": 572, + "ObjObjcharger": 574, + "ObjObjsonak": 575, + "ObjObjverm_egg_d1": 576, + "ObjObjverm_eggshell1": 577, + "ObjObjBW_bunker1": 578, + "ObjObjBW_top_platform": 579, + "ObjObjBW_top_connect1": 580, + "ObjObjBW_turret": 581, + "ObjObjBW_turret_gun": 582, + "ObjObjSmTimmy": 583, + "ObjObjSmBorjoyzee": 584, + "ObjObjTurret_gun": 585, + "ObjObjsonak_seat": 586, + "ObjObjBW_wall_100_window": 587, + "ObjObjBW_bunker_low": 588, + "ObjObjsmW_curvehi_m": 589, + "ObjObjsmW_house1": 590, + "ObjObjsmW_house2": 591, + "ObjObjsmW_house3": 592, + "ObjObjsmW_house4": 593, + "ObjObjsmW_curvemed_m": 594, + "ObjObjsmW_curvelow_m": 595, + "ObjObjsm_canopy_1_blue": 596, + "ObjObjsm_canopy_1_red": 597, + "ObjObjsm_canopy_1_green": 598, + "ObjObjSM_PANEL": 599, + "ObjObjfort_buttress": 600, + "ObjObjBW_sr_arch_150": 601, + "ObjObjBW_sr_arch_200": 602, + "ObjObjfort_slab": 603, + "ObjObjfort_statue": 604, + "ObjObjfort_drain": 605, + "ObjObjsm_raft": 606, + "ObjObjsonak_ring": 607, + "ObjObjturret_shell": 608, + "ObjObjPtree_simple": 609, + "ObjObjrpman_tracer": 610, + "ObjObjBW_debri_piece1": 611, + "ObjObjBW_debri_piece2": 612, + "ObjObjBW_debri_piece3": 613, + "ObjObjBW_debri_piece4": 614, + "ObjObjBW_debri_column1": 615, + "ObjObjBW_debri_column2": 616, + "ObjObjBW_debri_bunker1": 617, + "ObjObjshadow_blastmark_1": 618, + "ObjObjshadow_blastmark_2": 619, + "ObjObjdust_ring": 620, + "ObjObjwater_spray": 621, + "ObjObjdust_blast": 622, + "ObjObjmuzzle_flash": 623, + "ObjObjrpman_grenade": 624, + "ObjObjrpman_gunseat": 625, + "ObjObjdummy": 626, + "ObjObjmuzzle_flash2": 627, + "ObjObjdust_flash": 628, + "ObjObjripnest_chunk": 629, + "ObjObjShrap_Bigwall_1": 630, + "ObjObjShrap_Bigwall_2": 631, + "ObjObjShrap_Bigwall_3": 632, + "ObjObjShrap_Bigwall_4": 633, + "ObjObjShrap_Wood_1": 634, + "ObjObjShrap_Wood_2": 635, + "ObjObjShrap_Wood_3": 636, + "ObjObjShrap_Wood_4": 637, + "ObjObjShrap_Rock_1": 638, + "ObjObjShrap_Rock_2": 639, + "ObjObjShrap_Rock_3": 640, + "ObjObjShrap_Rock_4": 641, + "ObjObjShrap_Plant_1": 642, + "ObjObjShrap_Plant_2": 643, + "ObjObjShrap_Plant_3": 644, + "ObjObjShrap_Plant_4": 645, + "ObjObjShrap_Ground": 646, + "ObjObjmc_pickup_shells": 647, + "ObjObjmc_pickup_clips": 648, + "ObjObjmc_pickup_health": 649, + "ObjObjmc_pickup_grenades": 650, + "ObjObjmc_pickup_bush": 651, + "ObjObjBW_bunker1_D1": 652, + "ObjObjBW_bunker_top": 653, + "ObjObjBW_bunker_low_D1": 654, + "ObjObjBW_column_20_D1": 655, + "ObjObjBW_column_30_D1": 656, + "ObjObjBW_column_40_D1": 657, + "ObjObjBW_column_60_D1": 658, + "ObjObjBW_parapit_D1": 659, + "ObjObjmc_machinegun_shell": 660, + "ObjObjrpman_machinegun_shell": 661, + "ObjObjMCMuzzle_Flash": 662, + "ObjObjMCMuzzle_Flash2": 663, + "ObjObjptree_bob_d1": 664, + "ObjObjsm_staff": 665, + "ObjObjrpqueen": 666, + "ObjObjblast_ring": 667, + "ObjObjmc_shotgun_blast": 668, + "ObjObjrp_sword": 669, + "ObjObjsm_borj_house_l0": 670, + "ObjObjdust_ball": 671, + "ObjObjdust_smoke": 672, + "ObjObjreaper_test": 673, + "ObjObjmud_patch": 674, + "ObjObjmud_ball": 677, + "ObjObjhot_rock": 678, + "ObjObjMarker": 679, + "ObjObjrock_rpman_1": 680, + "ObjObjrock_rpman_2": 681, + "ObjObjhot_rock_D": 682, + "ObjObjlog_carrier": 683, + "ObjObjsmell": 684, + "ObjObjcleaner": 685, + "ObjObjbarracks": 686, + "ObjObjrock_rpman_3": 687, + "ObjObjlog_launcher": 688, + "ObjObjlog_launcher_base": 689, + "ObjObjhitcher": 690, + "ObjObjturret_gun_D": 691, + "ObjObjBarracks_D": 692, + "ObjObjrpman_tuba": 693, + "ObjObjmud_mold_dry": 694, + "ObjObjmud_mold_wet": 695, + "ObjObjcast_spell": 696, + "ObjObjrain": 697, + "ObjObjmud_mold_wet1": 698, + "ObjObjmud_mold_wet2": 699, + "ObjObjmud_mold_wet3": 700, + "ObjObjmud_mold_wet4": 701, + "ObjObjRpbomb": 702, + "ObjObjdelphi_dust": 703, + "ObjObjdelphi_dust_ball": 704, + "ObjObjbridge_200ft_d": 705, + "ObjObjbw_column_40_b": 706, + "ObjObjapple": 707, + "ObjObjWood_fence": 708, + "ObjObjWood_wall": 709, + "ObjObjWood_gift": 710, + "ObjObjWood_pub": 711, + "ObjObjWood_shop": 712, + "ObjObjWood_turret": 713, + "ObjObjStone_wall": 714, + "ObjObjStone_pub": 715, + "ObjObjStone_gift": 716, + "ObjObjStone_shop": 717, + "ObjObjStone_turret": 718, + "ObjObjMetal_shop": 719, + "ObjObjMetal_pub": 720, + "ObjObjMetal_turret": 721, + "ObjObjgift": 722, + "ObjObjMetal_gift": 723, + "ObjObjMetal_bunker": 724, + "ObjObjMetal_wall": 725, + "ObjObjShield_Extractor_1": 726, + "ObjObjShield_Extractor_2": 727, + "ObjObjShield_Extractor_3": 728, + "ObjObjExtractor_1": 729, + "ObjObjExtractor_2": 730, + "ObjObjExtractor_3": 731, + "ObjObjRp_pub_1": 732, + "ObjObjRp_pub_2": 733, + "ObjObjRp_pub_3": 734, + "ObjObjSpellshop_1": 735, + "ObjObjSpellshop_2": 736, + "ObjObjSpellshop_3": 737, + "ObjObjRp_pier": 738, + "ObjObjShield_1": 739, + "ObjObjShield_2": 740, + "ObjObjShield_3": 741, + "ObjObjsmyan": 742, + "ObjObjDeep_sea_monster": 743, + "ObjObjWood_gate": 744, + "ObjObjoffspring": 745, + "ObjObjoffspring_egg": 746, + "ObjObjoffspring_egg_d1": 747, + "ObjObjoffspring_eggshell1": 748, + "ObjObjkb_hotspot": 749, + "ObjObjsm_firepit": 750, + "ObjObjCOL_sm_firepit": 751, + "ObjObjsm_table_full": 752, + "ObjObjsm_shovel": 753, + "ObjObjsm_tankard": 754, + "ObjObjsm_hammer": 755, + "ObjObjsm_saw": 756, + "ObjObjsm_drumstick": 757, + "ObjObjsm_ribs": 758, + "ObjObjsm_pool": 759, + "ObjObjsm_podium": 760, + "ObjObjsm_planks": 761, + "ObjObjsm_woodshop_pile": 762, + "ObjObjD_wood_shop": 763, + "ObjObjD_stone_gift": 764, + "ObjObjD_stone_shop": 765, + "ObjObjD_metal_shop": 766, + "ObjObjD_metal_gift": 767, + "ObjObjd_wood_gift": 768, + "ObjObjD_wood_wall": 769, + "ObjObjD_metal_wall": 770, + "ObjObjD_stone_wall": 771, + "ObjObjD_wood_gate": 772, + "ObjObjD_stone_gate": 773, + "ObjObjD_metal_gate": 774, + "ObjObjstone_gate": 775, + "ObjObjmetal_gate": 776, + "ObjObjD_Metal_pub": 777, + "ObjObjD_Stone_pub": 778, + "ObjObjD_Wood_pub": 779, + "ObjObjtemp2": 780, + "ObjObjMcthrust_nitro": 781, + "ObjObjsm_bricks": 782, + "ObjObjsm_metal": 783, + "ObjObjrock_waiting": 784, + "ObjObjmc_launcher": 785, + "ObjObjmecctest": 786, + "ObjObjmc_snipergun": 787, + "ObjObjsm_book": 788, + "ObjObjrock_waiting_coll": 789, + "ObjObjmc_mortar": 790, + "ObjObjN_test": 791, + "ObjObjmc_pickup_sn_clips": 792, + "ObjObjmc_sniper_bullit": 793, + "ObjObjEFX_flash": 794, + "ObjObjEFX_cloud": 795, + "ObjObjEFX_debri1": 796, + "ObjObjEFX_debri2": 797, + "ObjObjEFX_fireball": 798, + "ObjObjEfx_shockwave": 799, + "ObjObjmc_rocket": 800, + "ObjObjmc_pickup_rockets": 801, + "ObjObjmc_pickup_lbombs": 802, + "ObjObjmc_rocket_proximity": 803, + "ObjObjmc_pickup_proximity": 804, + "ObjObjMC_mine": 805, + "ObjObjmc_rocket_homing": 806, + "ObjObjmc_pickup_homing": 807, + "ObjObjmc_lbomb": 808, + "ObjObjs6_dungeon": 809, + "ObjObjs6_cage": 810, + "ObjObjEFX_shockwave_W": 811, + "ObjObjEFX_cloud_dark": 812, + "ObjObjEFX_dustball": 813, + "ObjObjEFX_smoke_black": 814, + "ObjObjEFX_fire_trail": 815, + "ObjObjEFX_shockwave_B": 816, + "ObjObjEFX_ref_horiz_circle": 817, + "ObjObjEFX_ref_sphere": 818, + "ObjObjEFX_ref_plume": 819, + "ObjObjEFX_Bfire_trail": 820, + "ObjObjEFX_ref_line_back": 821, + "ObjObjmc_popupbomb": 822, + "ObjObjEFX_ref_line_up": 823, + "ObjObjEFX_shockwave_BH": 824, + "ObjObjEFX_smoke_blue": 826, + "ObjObjEFX_Gfire_trail": 827, + "ObjObjEFX_smoke_Mgrey": 828, + "ObjObjEFX_sniper_flash": 829, + "ObjObjsnowtree": 830, + "ObjObjWood_turret_gun": 831, + "ObjObjMetal_turret_gun": 832, + "ObjObjStone_turret_gun": 833, + "ObjObjsm_dropoff": 834, + "ObjObjbase_flag_red": 835, + "ObjObjbase_flag_blue": 836, + "ObjObjEFX_ref_line_L2R": 837, + "ObjObjEFX_wind_arrow": 838, + "ObjObjEFX_rain": 839, + "ObjObjEFX_snow": 840, + "ObjObjEFX_hail": 841, + "ObjObjEFX_shield_1": 842, + "ObjObjEFX_shield_2": 843, + "ObjObjEFX_shield_3": 844, + "ObjObjVimpFoodChunk": 845, + "ObjObjEFX_waterdrop": 846, + "ObjObjEFX_glint": 847, + "ObjObjEFX_bubble_reflection": 848, + "ObjObjEFX_bubble_hilight": 849, + "ObjObjEFX_bubble_glow": 850, + "ObjObjRP_smartie_waiting": 851, + "ObjObjEFX_spellshop_base": 852, + "ObjObjEFX_spellshop_window_y": 853, + "ObjObjEFX_water_ring": 854, + "ObjObjEFX_spellshop_window_r": 855, + "ObjObjEFX_spellshop_window_g": 856, + "ObjObjsm_podium_reap": 857, + "ObjObjsm_dropoff_reap": 858, + "ObjObjEFX_vimp_ghost": 859, + "ObjObjRP_pier_boat": 860, + "ObjObjEFX_water_bubble": 861, + "ObjObjEFX_ref_bubbles": 862, + "ObjObjWood_wall_coll": 863, + "ObjObjsmblue": 864, + "ObjObjCollision_test": 865, + "ObjObjEFX_blast_area_check": 866, + "ObjObjEFX_dust_ball": 867, + "ObjObjEFX_dust_swirl": 868, + "ObjObjEFX_mist": 869, + "ObjObjEFX_shield_hit_p1": 870, + "ObjObjRP_boat": 871, + "ObjObjEFX_smartie_spell": 872, + "ObjObjEFX_ref_ground_hit": 873, + "ObjObjEFX_snow_ball": 874, + "ObjObjEFX_snow_swirl": 875, + "ObjObjRP_boat_guns": 876, + "ObjObjRP_pier_coll": 877, + "ObjObjsm_firepit_coll": 878, + "ObjObjextractor_2_coll": 879, + "ObjObjextractor_1_coll": 880, + "ObjObjextractor_3_coll": 881, + "ObjObjrp_soul_dropoff": 882, + "ObjObjEFX_redlight": 883, + "ObjObjMr_invisible": 884, + "ObjObjefx_blue_wide": 885, + "ObjObjefx_ref_reap": 886, + "ObjObjEFX_ref_spin": 887, + "ObjObjEFX_ref_firewall": 888, + "ObjObjMetal_wall_coll": 889, + "ObjObjEFX_fire": 890, + "ObjObjStone_gate_coll": 891, + "ObjObjmc_jetpack_2": 892, + "ObjObjMetal_gate_coll": 893, + "ObjObjEFX_slow_spell": 894, + "ObjObjEFX_x": 895, + "ObjObjEFX_x_vert": 896, + "ObjObjmc_repairpack": 897, + "ObjObjmc_repairgun": 898, + "ObjObjEFX_lightning": 899, + "ObjObjEFX_wood_debri_1": 900, + "ObjObjEFX_wood_debri_2": 901, + "ObjObjmc_shield": 902, + "ObjObjrp_head": 903, + "ObjObjEFX_hail_missile": 904, + "ObjObjEFX_hail_shrapnel": 905, + "ObjObjmc_chunk1": 906, + "ObjObjmc_chunk2": 907, + "ObjObjmc_chunk3": 908, + "ObjObjmc_chunk4": 909, + "ObjObjmc_chunk5": 910, + "ObjObjmc_chunk6": 911, + "ObjObjEFX_metal_debri_1": 912, + "ObjObjEFX_stone_debri_1": 913, + "ObjObjEFX_splat": 914, + "ObjObjEFX_spray": 915, + "ObjObjEFX_blood": 916, + "ObjObjEFX_build_select": 917, + "ObjObjFun_house": 918, + "ObjObjEFX_mc_death": 919, + "ObjObjMC_bushpack": 920, + "ObjObjEFX_circle_spell": 921, + "ObjObjEFX_debri_3": 922, + "ObjObjEFX_ref_circle_out": 923, + "ObjObjEFX_ref_sphere_in": 924, + "ObjObjEFX_rp_target": 925, + "ObjObjEFX_prx_sphere": 926, + "ObjObjEFX_fire_roll": 927, + "ObjObjRP_bow_homing": 928, + "ObjObjRP_Bow_Sniper": 929, + "ObjObjRP_bow_rpg": 930, + "ObjObjRP_Bow_powerup": 931, + "ObjObjEFX_dark_fire": 932, + "ObjObjEFX_box_alpha": 933, + "ObjObjRP_Screamer": 934, + "ObjObjEFX_Bglow": 935, + "ObjObjD_fun_house": 936, + "ObjObjScott_test": 937, + "ObjObjEFX_blooddrop": 938, + "ObjObjEFX_cloud_layer": 939, + "ObjObjRP_turret_1_gun": 940, + "ObjObjRP_turret_1": 941, + "ObjObjEFX_ice_target": 942, + "ObjObjEFX_red_smartie": 943, + "ObjObjEFX_blue_smartie": 944, + "ObjObjoffs_hotspot": 945, + "ObjObjEFX_Swirl": 946, + "ObjObjEFX_lightning_1": 947, + "ObjObjEFX_lightning_2": 948, + "ObjObjEFX_rainbow": 949, + "ObjObjEFX_RP_debri_1": 950, + "ObjObjsm_flag": 951, + "ObjObjsm_flag1": 952, + "ObjObjsm_flag2": 953, + "ObjObjsm_flag3": 954, + "ObjObjEFX_sun_yellow": 955, + "ObjObjEFX_sun_yellow_f": 956, + "ObjObjWood_pub_coll": 957, + "ObjObjEFX_green_smartie": 958, + "ObjObjEFX_clockhand_1": 959, + "ObjObjEFX_clockhand_2": 960, + "ObjObjD_wood_turret": 961, + "ObjObjD_stone_turret": 962, + "ObjObjD_metal_turret": 963, + "ObjObjEFX_bow_charged": 964, + "ObjObjEFX_fire_ring": 965, + "ObjObjEFX_splash": 966, + "ObjObjD_spellshop_1": 967, + "ObjObjD_spellshop_2": 968, + "ObjObjD_spellshop_3": 969, + "ObjObjD_extractor_2": 970, + "ObjObjD_rp_pier": 971, + "ObjObjD_rp_boat": 972, + "ObjObjD_Extractor_3": 973, + "ObjObjD_Shield_Extractor_1": 974, + "ObjObjD_Shield_Extractor_2": 975, + "ObjObjD_Shield_Extractor_3": 976, + "ObjObjBone_femur": 977, + "ObjObjBone_rib": 978, + "ObjObjBone_spine": 979, + "ObjObjEFX_3dXhair": 980, + "ObjObjMecc_base_template_1": 981, + "ObjObjS_mecc_bunker": 982, + "ObjObjS_mecc_teleport": 983, + "ObjObjS_mecc_Gpad": 984, + "ObjObjRP_base_template_1": 985, + "ObjObjS_mecc_shop": 986, + "ObjObjS_mecc_shop_coll": 987, + "ObjObjS_mecc_tower": 988, + "ObjObjS_reaper_shop": 989, + "ObjObjS_reaper_bunker": 990, + "ObjObjGyro": 991, + "ObjObjShrub1": 992, + "ObjObjShrub2": 993, + "ObjObjShrub3": 994, + "ObjObjShrub4": 995, + "ObjObjShrub5": 996, + "ObjObjShrub6": 997, + "ObjObjShrub7": 998, + "ObjObjShrub8": 999, + "ObjObjNick_test": 1000, + "ObjObjW_story1_hang": 1001, + "ObjObjSMW_house5": 1002, + "ObjObjSMW_house6": 1003, + "ObjObjLight": 1004, + "ObjObjpiranha": 1005, + "ObjObjPtree_bob_busted": 1006, + "ObjObjGuard_center": 1007, + "ObjObjW_story1_ramp_1": 1008, + "ObjObjW_story1_ramp_2": 1009, + "ObjObjW_story1_ramp_3": 1010, + "ObjObjW_story1_ramp_4": 1011, + "ObjObjW_story1_rock_1": 1012, + "ObjObjW_story1_rock_2": 1013, + "ObjObjW_story1_rock_3": 1014, + "ObjObjBW_gate_swing": 1015, + "ObjObjEFX_blur": 1016, + "ObjObjSphere_coll": 1017, + "ObjObjKabuto_shield": 1018, + "ObjObjMU_MPselect": 1019, + "ObjObjefx_menu": 1020, + "ObjObjBW_drawbridge": 1021, + "ObjObjBW_fence": 1022, + "ObjObjBW_prison": 1023, + "ObjObjfun_house_int": 1024, + "ObjObjMU_IDselect": 1025, + "ObjObjMU_WDselect": 1026, + "ObjObjMU_GNselect": 1027, + "ObjObjMCtower": 1028, + "ObjObjshrub9": 1029, + "ObjObjshrub10": 1030, + "ObjObjshrub11": 1031, + "ObjObjshrub12": 1032, + "ObjObjshrub13": 1033, + "ObjObjshrub14": 1034, + "ObjObjshrub15": 1035, + "ObjObjshrub16": 1036, + "ObjObjshrub17": 1037, + "ObjObjshrub18": 1038, + "ObjObjshrub19": 1039, + "ObjObjshrub20": 1040, + "ObjObjMCbarrack": 1041, + "ObjObjDesert_rock_1": 1042, + "ObjObjDesert_rock_2": 1043, + "ObjObjDesert_rock_3": 1044, + "ObjObjPtree_canopy": 1045, + "ObjObjCloud_story1": 1046, + "ObjObjrpm_snipergun": 1047, + "ObjObjrpm_bazooka": 1048, + "ObjObjrpm_jetpack": 1049, + "ObjObjGuard_Tower1": 1050, + "ObjObjGuard_tower2": 1051, + "ObjObjmarker_spline": 1052, + "ObjObjstory4": 1053, + "ObjObj1sonak_4guards": 1054, + "ObjObjRpm_torch": 1055, + "ObjObjBW_drawbridge_open": 1056, + "ObjObjstory4_gate": 1057, + "ObjObj1Tsonak_4guards": 1058, + "ObjObj1MCsonak_4guards": 1059, + "ObjObjbw_minibarracks": 1060, + "ObjObjGuard_SAM": 1061, + "ObjObjGuard_turret": 1062, + "ObjObjbw_prisoncrater": 1063, + "ObjObjcharger_hotspot": 1064, + "ObjObjGuard_lift": 1065, + "ObjObjGuard_lift_strut": 1066, + "ObjObj2x4_guards": 1067, + "ObjObj2x5_guards": 1068, + "ObjObj2x3_guards": 1069, + "ObjObj2x2_guards": 1070, + "ObjObj2x1_guards": 1071, + "ObjObjGuard_bunker": 1072, + "ObjObjsm_plate": 1073, + "ObjObjGuard_stable": 1074, + "ObjObjPOTATO": 1075, + "ObjObjrp_jetski": 1076, + "ObjObjBW_reapertower": 1077, + "ObjObjpotato_basket": 1078, + "ObjObjrpm_telescope": 1079, + "ObjObjRaik": 1080, + "ObjObjiceberg1": 1081, + "ObjObjsm_pagoda": 1082, + "ObjObjsm_pagodagong": 1083, + "ObjObjsm_pagodagate": 1084, + "ObjObjiceberg2": 1085, + "ObjObjiceberg3": 1086, + "ObjObjiceberg4": 1087, + "ObjObjiceberg_ramp": 1088, + "ObjObjice_wall": 1089, + "ObjObjstory5": 1090, + "ObjObjsmborjoyzee_staff": 1091, + "ObjObjguard_shop": 1092, + "ObjObjStone_command": 1093, + "ObjObjguard_lift_base": 1094, + "ObjObjWood_command": 1095, + "ObjObjstory3_ridge": 1096, + "ObjObjGuard_buoy": 1097, + "ObjObjbuoy_spline": 1098, + "ObjObjp_jetski_homing": 1099, + "ObjObjp_jetski_missile": 1100, + "ObjObjp_jetski_turbo": 1101, + "ObjObjEFX_sunflare": 1102, + "ObjObjrp_grenade_test": 1103, + "ObjObjrip_gore_head": 1104, + "ObjObjrip_gore_arm": 1105, + "ObjObjEFX_ref_machinegun": 1106, + "ObjObjEFX_sniper_flash2": 1107, + "ObjObjEFX_smoke_ring": 1108, + "ObjObjEFX_ref_vert_circle": 1109, + "ObjObjEFX_shotgun_blast": 1111, + "ObjObjEFX_ripper_Lspit": 1112, + "ObjObjEFX_ripper_Mspit": 1113, + "ObjObjMC_shotgun_shell": 1114, + "ObjObj1Tsonak": 1115, + "ObjObjrpman_sonak_shell": 1116, + "ObjObjVimpfoodchunk1": 1117, + "ObjObjVimpfoodchunk2": 1118, + "ObjObjVimpfoodchunk3": 1119, + "ObjObjEFX_sam_debri": 1120, + "ObjObjEFX_ref_sam_explode": 1121, + "ObjObjEFX_ref_turret_explode": 1122, + "ObjObjmc_pickup_mines": 1123, + "ObjObjEFX_turret_debri": 1124, + "ObjObjEFX_smoke_ring_white": 1125, + "ObjObjGiants_logo_3D": 1126, + "ObjObjGuard_tower1D": 1127, + "ObjObjGuard_bunkerD": 1128, + "ObjObjGuard_tower2D": 1129, + "ObjObjEFX_sunflare2": 1130, + "ObjObjefx_kentestobj1": 1131, + "ObjObjefx_kentestobj2": 1132, + "ObjObjefx_kentestobj3": 1133, + "ObjObjEFX_stable_debri_2": 1134, + "ObjObjEFX_stable_debri_1": 1135, + "ObjObjEFX_stable_debri_3": 1136, + "ObjObjEFX_stable_debri_4": 1137, + "ObjObjGuard_stableD": 1138, + "ObjObjEFX_sun_orange": 1139, + "ObjObjEFX_guard_tower2": 1140, + "ObjObjEFX_guard_tower_debri": 1141, + "ObjObjefx_smoke_green": 1142, + "ObjObjRP1_arm_base": 1143, + "ObjObjPtree_bob_coll": 1144, + "ObjObjEFX_MC_lbomb": 1145, + "ObjObjRstory4": 1146, + "ObjObjR3_start_finish": 1147, + "ObjObjmagic_wall1": 1148, + "ObjObjmagic_wall2": 1149, + "ObjObjmagic_gate1": 1150, + "ObjObjmagic_gate2": 1151, + "ObjObjrp_workshop": 1152, + "ObjObjd_rp_workshop": 1153, + "ObjObjrp_generator": 1154, + "ObjObjd_rp_generator": 1155, + "ObjObjrp_fun_house": 1156, + "ObjObjd_rp_fun_house": 1157, + "ObjObjrp_command": 1158, + "ObjObjrpm_jetski": 1159, + "ObjObjR3_lap_marker": 1160, + "ObjObjGuard_army_barracks": 1161, + "ObjObjarmy_spline": 1162, + "ObjObjpebble": 1163, + "ObjObjR_grid": 1164, + "ObjObjEFX_Rstory5_volcano": 1165, + "ObjObjRstory5_cave": 1166, + "ObjObjbw_giantwall": 1167, + "ObjObjToby": 1168, + "ObjObjstory4_door": 1169, + "ObjObjEFX_ice_wall_debri": 1170, + "ObjObjReaper_ship": 1171, + "ObjObjReaper_ship_husk": 1172, + "ObjObjGuard_army_barracks_husk": 1173, + "ObjObj7_flying_guards": 1174, + "ObjObjmag_crystal": 1175, + "ObjObj1_ripper": 1176, + "ObjObj2_rippers": 1177, + "ObjObj3_rippers": 1178, + "ObjObj1_sniper": 1179, + "ObjObj1_kamikazi": 1180, + "ObjObjs_reaper_pier": 1181, + "ObjObjs_mecc_sam": 1185, + "ObjObjs_mecc_turret": 1186, + "ObjObjs_reaper_turret": 1187, + "ObjObjs_reaper_sam": 1188, + "ObjObjs_reaper_tower": 1189, + "ObjObjbarracks_husk": 1190, + "ObjObjbump_test": 1191, + "ObjObjs_reaper_portal": 1192, + "ObjObjmother_ship": 1198, + "ObjObjmag_crystal_shard": 1199, + "ObjObjyan_sword": 1200, + "ObjObjmc_cutout1": 1201, + "ObjObjmc_cutout2": 1202, + "ObjObjrpm_bomb": 1203, + "ObjObjkabuto_stone": 1204, + "ObjObjefx_portal": 1205, + "ObjObjEFX_mc_rocket": 1206, + "ObjObjgiantwall1": 1207, + "ObjObjgiantwall2": 1208, + "ObjObjgiantwall3": 1209, + "ObjObjkab_ash": 1210, + "ObjObjGuard_portal": 1211, + "ObjObjsm_timmygrave": 1212, + "ObjObjGuard_portal_M": 1213, + "ObjObjReaper_Galleon": 1214, + "ObjObjK_rock_gen": 1215, + "ObjObjK_pocket": 1216, + "ObjObjsmdoomed_l0": 1217, + "ObjObjsmd_ground": 1218, + "ObjObj5_flying_guards": 1219, + "ObjObj3_flying_guards": 1220, + "ObjObjEFX_portal_charm": 1221, + "ObjObjRP_mine": 1222, + "ObjObjRP_pickup_mines": 1223, + "ObjObjRP_health": 1224, + "ObjObjRP_pickup_health": 1225, + "ObjObjguard_ripperbarracks": 1226, + "ObjObjd_extractor_2_coll": 1227, + "ObjObjD_magic_wall1": 1228, + "ObjObjD_magic_wall2": 1229, + "ObjObjD_magic_gate1": 1230, + "ObjObjD_magic_gate2": 1231, + "ObjObjd_ext2_coll": 1232, + "ObjObjRP_pickup_repair": 1233, + "ObjObjW_story1_walls": 1234, + "ObjObjw_story1_arch": 1235, + "ObjObjw_story1_entrance": 1236, + "ObjObjd_stone_command": 1237, + "ObjObjd_rp_command": 1238, + "ObjObjRaikTrail": 1239, + "ObjObjRPqueenTrail": 1240, + "ObjObjReg_kiss": 1241, + "ObjObjK_lava_ball": 1242, + "ObjObjK_volcano_debri": 1243, + "ObjObjK_exhaust": 1244, + "ObjObjEFX_repair_ring": 1245, + "ObjObjK_rock_gen_top": 1246, + "ObjObjw_story1_mine": 1247, + "ObjObjw_story1_walls_1": 1248, + "ObjObjw_story1_walls_2": 1249, + "ObjObjw_story1_walls_3": 1250, + "ObjObjw_story1_walls_4": 1251, + "ObjObjw_story1_walls_5": 1252, + "ObjObjw_story1_walls_6": 1253, + "ObjObjCharger_snow": 1254, + "ObjObjEFX_magic_W1": 1255, + "ObjObjEFX_portal_open_loop": 1256, + "ObjObjEFX_portal_open_flick": 1257, + "ObjObjEFX_portal_close_flick": 1258, + "ObjObjw_story1_hang_flick": 1259, + "ObjObjshrub5_coll": 1274, + "ObjObjRipper_radius": 1275, + "ObjObjBarracks_story2": 1276, + "ObjObjgiantwall4": 1277, + "ObjObjA_M1_near_beach": 1279, + "ObjObjA_M2_mnt_beach": 1280, + "ObjObjA_M3_cliffs_sand": 1281, + "ObjObjA_M4_beach_dark": 1282, + "ObjObjA_M5_beach_waves": 1283, + "ObjObjA_R1_light_rain": 1284, + "ObjObjA_R2_snow": 1285, + "ObjObjA_R3_race": 1286, + "ObjObjA_R4_darker": 1287, + "ObjObjA_R5_mountain": 1288, + "ObjObjA_K1": 1289, + "ObjObjA_K5_storm": 1290, + "ObjObjA_crashed_lander": 1291, + "ObjObjA_floating_gate": 1293, + "ObjObjA_cage": 1295, + "ObjObjA_distant_birds": 1296, + "ObjObjA_wind_gusts": 1297, + "ObjObjA_single_tree": 1298, + "ObjObjA_trees": 1299, + "ObjObjA_shoreline": 1300, + "ObjObjA_pools": 1301, + "ObjObjA_pier": 1302, + "ObjObjA_big_leaf_tree": 1303, + "ObjObjA_reaper_tower": 1304, + "ObjObjA_int_volcano": 1305, + "ObjObjA_Smartie_village": 1306, + "ObjObjA_high_village": 1307, + "ObjObjA_high_winds": 1308, + "ObjObjA_prison": 1309, + "ObjObjA_army_barracks": 1310, + "ObjObjA_forest_trees": 1312, + "ObjObjA_distant_animals": 1313, + "ObjObj4_wide_guards": 1314, + "ObjObjA_shoreline_long": 1315, + "ObjObjA_shoreline_dark_short": 1316, + "ObjObjA_shoreline_dark_long": 1317, + "ObjObjA_river": 1318, + "ObjObjA_high_winds_light": 1319, + "ObjObjA_cold_wind_gusts": 1320, + "ObjObjA_cold_winds_gusts": 1321, + "ObjObjEFX_giantwall4": 1322, + "ObjObjA_kabuto_temp": 1323, + "ObjObjA_mecc_temp": 1324, + "ObjObjA_mecc_temp_amb": 1325, + "ObjObjA_mecc_temp_battle": 1326, + "ObjObjA_mecc_temp_sus": 1327, + "ObjObjstory4_tower": 1328, + "ObjObjsmf_healthy": 1329, + "ObjObjGuard_buoy_coll": 1330, + "ObjObjrpm_jetski_coll": 1331, + "ObjObjefx_magic_w2": 1332, + "ObjObjgiantwall5": 1333, + "ObjObjkabutopad": 1334, + "ObjObjsmW_house7": 1335, + "ObjObjsmW_house8": 1336, + "ObjObjsm_evil": 1337, + "ObjObjA_k2": 1338, + "ObjObjA_k3": 1339, + "ObjObjA_k4": 1340, + "ObjObjA_special_tree": 1342, + "ObjObjA_pools_large": 1343, + "ObjObjA_boat": 1344, + "ObjObjmagic_wall1_coll": 1346, + "ObjObjmagic_wall2_coll": 1347, + "ObjObjsm_tower_timmy": 1348, + "ObjObjp_jetski_coll": 1349, + "ObjObjefx_magic_gate1": 1350, + "ObjObjefx_magic_gate2": 1351, + "ObjObjmagic_gate1_coll": 1352, + "ObjObjmagic_gate2_coll": 1353, + "ObjObjsm_table_dad": 1354, + "ObjObjA_Volcano": 1355, + "ObjObjRstory5_volcano_coll": 1356, + "ObjObjRstory5_fake": 1357, + "ObjObjefx_flare": 1358, + "ObjObjgiantwall3_nick": 1359, + "ObjObjEFX_offspring_spit": 1360, + "ObjObjEFX_offspring_fire": 1361, + "ObjObjs_gpad_coll": 1362, + "ObjObjEFX_red_rings": 1363, + "ObjObjEFX_ref_crooked_line": 1364, + "ObjObjEFX_whizzer": 1365, + "ObjObjEFX_whizzer_sparkles": 1366, + "ObjObjEFX_deep_red": 1367, + "ObjObjEFX_whizzer_charmL": 1368, + "ObjObjEFX_whizzer_charmR": 1369, + "ObjObjK_spike": 1370, + "ObjObjK_bridge_1": 1371, + "ObjObjK_bridge_2": 1372, + "ObjObjK_bridge_3": 1373, + "ObjObjsign": 1374, + "ObjObjEFX_crystal_debri": 1375, + "ObjObjEFX_ref_minibarracks": 1376, + "ObjObjEFX_mini_debri_top": 1377, + "ObjObjEFX_mini_debri_1": 1378, + "ObjObjEFX_mini_debri_2": 1379, + "ObjObjEFX_mini_debri_3": 1380, + "ObjObjEFX_ref_guard_tower_1": 1381, + "ObjObjEFX_guard_tower_debri_1": 1382, + "ObjObjEFX_guard_tower_debri_2": 1383, + "ObjObjEFX_guard_tower_debri_3": 1384, + "ObjObjEFX_guard_tower_debri_4": 1385, + "ObjObjEFX_guard_tower_debri_5": 1386, + "ObjObjEFX_ref_guard_tower_2": 1387, + "ObjObjEFX_tower_2_debri_1": 1388, + "ObjObjEFX_tower_2_debri_2": 1389, + "ObjObjEFX_tower_2_debri_3": 1390, + "ObjObjEFX_rpbarracks_debri_1": 1391, + "ObjObjEFX_rpbarracks_debri_2": 1392, + "ObjObjEFX_rpbarracks_debri_3": 1393, + "ObjObjEFX_ref_giantwall3": 1394, + "ObjObjEFX_giantwall_debri_1": 1395, + "ObjObjEFX_giantwall_debri_2": 1396, + "ObjObjEFX_giantwall_debri_3": 1397, + "ObjObjEFX_giantwall_debri_4": 1398, + "ObjObjEFX_giantwall_debri_5": 1399, + "ObjObjEFX_giantwall_debri_6": 1400, + "ObjObjEFX_giantwall_debri_7": 1401, + "ObjObjEFX_giantwall_debri_8": 1402, + "ObjObjEFX_giantwall_debri_9": 1403, + "ObjObjEFX_giantwall_debri_10": 1404, + "ObjObjEFX_giantwall_debri_11": 1405, + "ObjObjEFX_giantwall_debri_12": 1406, + "ObjObjEFX_giantwall_debri_13": 1407, + "ObjObjEFX_giantwall_debri_14": 1408, + "ObjObjEFX_ref_giantwall5": 1409, + "ObjObjEFX_giantwall5_debri_1": 1410, + "ObjObjEFX_giantwall3_debri_s": 1411, + "ObjObjEFX_smoke_ring_b": 1412, + "ObjObjBridge_wide": 1413, + "ObjObjBW_drawbridge_coll": 1414, + "ObjObjBW_drawbridgeO_coll": 1415, + "ObjObjK_rock_gen_coll": 1416, + "ObjObjEFX_soot": 1417, + "ObjObjRW_circle_spell": 1418, + "ObjObjfeather1_timer": 1420, + "ObjObjEFX_blast_area_check_mkr": 1422, + "ObjObjEFX_3dXhair_marker": 1423, + "ObjObjMr_invisible_physics": 1425, + "ObjObjMecc_sonak": 1426, + "ObjObjMr_invisible_repair": 1427, + "ObjObjMr_invisible_firewall": 1428, + "ObjObjReaper_fake": 1429, + "ObjObjMr_invisible_fire": 1430, + "ObjObjR_husk_damage2_husk": 1432, + "ObjObjEFX_ref_sphere_vsoul": 1434, + "ObjObjRP_bow_rpg_pickup": 1444, + "ObjObjRP_Bow_Sniper_pickup": 1445, + "ObjObjRP_bow_homing_pickup": 1446, + "ObjObjRP_Bow_powerup_pickup": 1447, + "ObjObjbase_flag_red2": 1448, + "ObjObjplayer_flag_red": 1449, + "ObjObjEFX_dust_particle": 1450, + "ObjObjRipSpitProj": 1451, + "ObjObjshrub1_snow": 1452, + "ObjObjEFX_shockwave_LB": 1453, + "ObjObjEFX_emp_blast": 1454, + "ObjObjEFX_rp_Bspell_trail": 1455, + "ObjObjEFX_rp_Bspell_glow": 1456, + "ObjObjEFX_rp_Gspell_trail": 1457, + "ObjObjEFX_rp_Rspell_trail": 1458, + "ObjObjEFX_rp_Gspell_glow": 1459, + "ObjObjEFX_rp_Rspell_glow": 1460 + }, + "sfx": { + "SfxNone": -1, + "SfxRPManShortHit1": 118, + "SfxRPManShortHit2": 119, + "SfxRPManHit1": 120, + "SfxRPManHit2": 121, + "SfxRPManHit3": 122, + "SfxRPManHit4": 123, + "SfxRPManWhisp1": 125, + "SfxRPManWhisp2": 126, + "SfxRPManWhisp3": 127, + "SfxRPManWho": 128, + "SfxRPManAnswer1": 129, + "SfxRPManBush": 130, + "SfxRPManDie1": 131, + "SfxRPManDie2": 132, + "SfxRPManDie3": 133, + "SfxRPManDie4": 134, + "SfxRPManDie5": 135, + "Sfxrain_medium": 220, + "Sfxrain_downpour": 223, + "SfxSr_mana1": 266, + "SfxWp_missl": 267, + "sfxgong_1": 398, + "sfxMC_drowning": 412, + "sfxSR_SWMLP": 415, + "sfxSR_FSTK1": 416, + "sfxSR_FSTK2": 417, + "sfxME_msls1": 428, + "sfxSR_BLDEN": 816, + "sfxSR_BLDLP": 817, + "sfxSR_BLDST": 818, + "sfxSR_BTOSW": 820, + "sfxSR_DRPWP": 823, + "sfxSR_FALL1": 824, + "sfxSR_FALL2": 825, + "sfxSR_FLYEN": 828, + "sfxSR_FLYLP": 829, + "sfxSR_FLYST": 830, + "sfxSR_FSGR1": 832, + "sfxSR_FSGR2": 833, + "sfxSR_FSKTB": 844, + "sfxSR_FSMT1": 845, + "sfxSR_FSMT2": 846, + "sfxSR_FSSA1": 849, + "sfxSR_FSSA2": 850, + "sfxSR_FSSN1": 853, + "sfxSR_FSSN2": 854, + "sfxSR_FSST1": 857, + "sfxSR_FSST2": 858, + "sfxSR_FSWA1": 861, + "sfxSR_FSWA2": 862, + "sfxSR_FSWD1": 865, + "sfxSR_FSWD2": 866, + "sfxSR_FSWG1": 869, + "sfxSR_FSWG2": 870, + "sfxSR_HBWPL": 873, + "sfxSR_HBWSH": 874, + "sfxSR_HBWSL": 875, + "sfxSR_HBWTA": 876, + "sfxSR_HFAL1": 878, + "sfxSR_HFAL2": 879, + "sfxSR_MANA2": 901, + "sfxSR_PBWPL": 904, + "sfxSR_PBWSH": 905, + "sfxSR_PBWSL": 906, + "sfxSR_RBWPL": 908, + "sfxSR_RBWSH": 909, + "sfxSR_RBWSL": 910, + "sfxSR_RPGPL": 911, + "sfxSR_RPGSH": 912, + "sfxSR_RPGSL": 913, + "sfxSR_SBWPL": 916, + "sfxSR_SBWSH": 917, + "sfxSR_SBWSL": 918, + "sfxSR_SBWZI": 919, + "sfxSR_SLD1": 921, + "sfxSR_SMRTD": 923, + "sfxSR_SPCA1": 924, + "sfxSR_SPCA2": 925, + "sfxSR_SPCA3": 926, + "sfxSR_SPCLE": 927, + "sfxSR_SPCLL": 928, + "sfxSR_SPCLM": 929, + "sfxSR_SPCLS": 930, + "sfxSR_SPCLU": 931, + "sfxSR_SPCA4": 932, + "sfxSR_SPFHE": 933, + "sfxSR_SPFHL": 934, + "sfxSR_SPFHS": 935, + "sfxSR_SPFLA": 936, + "sfxSR_SPFLB": 937, + "sfxSR_SPFLC": 938, + "sfxSR_SPFLD": 939, + "sfxSR_SPFSH": 941, + "sfxSR_SPHEL": 942, + "sfxSR_SPREP": 943, + "sfxSR_SPSFC": 945, + "sfxSR_SPSFL": 946, + "sfxSR_SPSFS": 947, + "sfxSR_SPSGE": 948, + "sfxSR_SPSGL": 949, + "sfxSR_SPSGS": 950, + "sfxSR_SPSHF": 951, + "sfxSR_SPSHH": 952, + "sfxSR_SPSHP": 953, + "sfxSR_SPSHR": 954, + "sfxSR_SPSHS": 955, + "sfxSR_SPSHT": 956, + "sfxSR_SPSTE": 957, + "sfxSR_SPSTL": 958, + "sfxSR_SPSTS": 959, + "sfxSR_SPTEL": 960, + "sfxSR_SPTOE": 961, + "sfxSR_SPTOL": 962, + "sfxSR_SPTOS": 963, + "sfxSR_STOHB": 964, + "sfxSR_STOPB": 965, + "sfxSR_STORB": 966, + "sfxSR_STORP": 967, + "sfxSR_STOSB": 968, + "sfxSR_SWHT1": 969, + "sfxSR_SWHT2": 970, + "sfxSR_SWSH1": 971, + "sfxSR_SWSH2": 973, + "sfxSR_VMPSD": 974, + "sfxKA_2HAND": 1017, + "sfxKA_ADPN": 1018, + "sfxKA_ATTCK": 1019, + "sfxKA_BELCH": 1020, + "sfxKA_BELLY": 1021, + "sfxKA_BITE1": 1022, + "sfxKA_BITE2": 1023, + "sfxKA_BPNC1": 1026, + "sfxKA_BPNC2": 1027, + "sfxKA_BRETH": 1030, + "sfxKA_BRNLP": 1031, + "sfxKA_BRNND": 1032, + "sfxKA_BRNST": 1033, + "sfxKA_BRTH": 1034, + "sfxKA_BUTT": 1035, + "sfxKA_CANON": 1036, + "sfxKA_DETH1": 1037, + "sfxKA_DETH2": 1038, + "sfxKA_EAT1": 1041, + "sfxKA_EAT2": 1042, + "sfxKA_EGG1": 1045, + "sfxKA_EGG2": 1046, + "sfxKA_ELBOW": 1049, + "sfxKA_FETCH": 1050, + "sfxKA_FRWTR": 1051, + "sfxKA_FSDI1": 1052, + "sfxKA_FSDI2": 1053, + "sfxKA_FSGR1": 1056, + "sfxKA_FSGR2": 1057, + "sfxKA_FSMT1": 1060, + "sfxKA_FSMT2": 1061, + "sfxKA_FSSA1": 1064, + "sfxKA_FSSA2": 1065, + "sfxKA_FSSN1": 1068, + "sfxKA_FSSN2": 1069, + "sfxKA_FSST1": 1072, + "sfxKA_FSST2": 1073, + "sfxKA_FSWA1": 1076, + "sfxKA_FSWA2": 1077, + "sfxKA_FSWG1": 1080, + "sfxKA_FSWG2": 1081, + "sfxKA_GRAB": 1084, + "sfxKA_HVHT1": 1085, + "sfxKA_HVHT2": 1086, + "sfxKA_JSTMP": 1089, + "sfxKA_JUMP2": 1090, + "sfxKA_LIPS": 1091, + "sfxKA_LNDHD": 1092, + "sfxKA_LTHT1": 1093, + "sfxKA_LTHT2": 1094, + "sfxKA_MAGCL": 1106, + "sfxKA_MAGLP": 1107, + "sfxKA_MAGOP": 1109, + "sfxKA_MDHT1": 1111, + "sfxKA_MDHT2": 1112, + "sfxKA_OFDIE": 1115, + "sfxKA_PNCH1": 1116, + "sfxKA_PNCH2": 1117, + "sfxKA_RETRN": 1120, + "sfxKA_RNGND": 1122, + "sfxKA_RNKND": 1125, + "sfxKA_ROAR1": 1127, + "sfxKA_ROAR2": 1128, + "sfxKA_ROAR3": 1129, + "sfxKA_ROAR4": 1130, + "sfxKA_RSPK1": 1131, + "sfxKA_RSPK2": 1132, + "sfxKA_SCRAT": 1136, + "sfxKA_SIGH": 1137, + "sfxKA_SLID1": 1138, + "sfxKA_SMRT1": 1140, + "sfxKA_SMRT2": 1141, + "sfxKA_SNIFF": 1144, + "sfxKA_SPIK1": 1145, + "sfxKA_SPIK2": 1146, + "sfxKA_STOMP": 1149, + "sfxKA_STRN": 1150, + "sfxKA_SWLL": 1151, + "sfxKA_THROW": 1152, + "sfxKA_VIMP1": 1153, + "sfxKA_VIMP2": 1154, + "sfxKA_WOUND": 1157, + "sfxKA_WTRLP": 1158, + "sfxKA_WTRND": 1159, + "sfxKA_WTRST": 1160, + "sfxKA_YAWN": 1161, + "sfxCA_DEAT1": 1162, + "sfxCA_DEAT2": 1163, + "sfxCA_FOOT1": 1164, + "sfxCA_INJR1": 1168, + "sfxCA_INJR2": 1169, + "sfxCA_ROAR": 1170, + "sfxCL_EATEN": 1172, + "sfxCL_EATLP": 1173, + "sfxCL_EATST": 1174, + "sfxCR_CAW1": 1190, + "sfxCR_CAW2": 1191, + "sfxCR_DEAT1": 1193, + "sfxCR_DEAT2": 1194, + "sfxOF_EAT1": 1195, + "sfxOF_FTCH1": 1196, + "sfxOF_FUT1": 1197, + "sfxOF_GROW": 1201, + "sfxOF_HATCH": 1202, + "sfxOF_IDLE1": 1203, + "sfxOF_IDLE2": 1204, + "sfxOF_WFUT1": 1205, + "sfxPI_SWRM1": 1216, + "sfxPI_SWRM2": 1217, + "sfxLB_FALL1": 1218, + "sfxLB_SQUA1": 1220, + "sfxLB_SQUA2": 1221, + "sfxLB_WING1": 1223, + "sfxRL_ATFR1": 1227, + "sfxRL_ATFR2": 1228, + "sfxRL_ATTK1": 1231, + "sfxRL_CHITT": 1235, + "sfxRL_DEAT1": 1236, + "sfxRL_DEAT2": 1237, + "sfxRL_FEET": 1238, + "sfxRL_FREXP1": 1240, + "sfxRL_FREXP2": 1241, + "sfxRL_GENER": 1243, + "sfxRL_INJR1": 1244, + "sfxRL_INJR2": 1245, + "sfxRL_OUTG1": 1246, + "sfxRL_RETR1": 1248, + "sfxRM_ATFR1": 1250, + "sfxRM_ATFR2": 1251, + "sfxRM_ATTK1": 1254, + "sfxRM_BURL": 1256, + "sfxRM_CHITT": 1258, + "sfxRM_DEAT1": 1259, + "sfxRM_DEAT2": 1260, + "sfxRM_FEET": 1261, + "sfxRM_FREXP": 1263, + "sfxRM_INJ01": 1265, + "sfxRM_INJ02": 1266, + "sfxRM_OUTG1": 1267, + "sfxRM_RETR1": 1269, + "sfxRS_ATTK1": 1271, + "sfxRS_ATTK2": 1272, + "sfxRS_CHITT": 1275, + "sfxRS_DEAT1": 1276, + "sfxRS_DEAT2": 1277, + "sfxRS_FEET": 1278, + "sfxRS_GENER": 1279, + "sfxRS_INJR1": 1280, + "sfxRS_INJR2": 1281, + "sfxSE_LUNGE": 1287, + "sfxSE_ROAR1": 1288, + "sfxSM_FRPFL": 1290, + "sfxSM_FRPHI": 1291, + "sfxSM_FRPLT": 1292, + "sfxSO_ATSOL": 1296, + "sfxSO_ATST1": 1297, + "sfxSO_DEAT1": 1299, + "sfxSO_DEAT2": 1300, + "sfxSO_FUT1": 1301, + "sfxSO_IDLE1": 1305, + "sfxSO_IDLE2": 1306, + "sfxSO_INJR1": 1307, + "sfxSO_INJR2": 1308, + "sfxSO_ROAR1": 1309, + "sfxSO_ROAR2": 1310, + "sfxSO_SNRT1": 1312, + "sfxSO_SNRT2": 1313, + "sfxVE_ATFR1": 1318, + "sfxVE_ATFR2": 1319, + "sfxVE_CHITT": 1320, + "sfxVE_DEAT1": 1321, + "sfxVE_DEAT2": 1322, + "sfxVE_EGGRO": 1323, + "sfxVE_EGHTC": 1324, + "sfxVE_EGLAY": 1325, + "sfxVE_FOOT1": 1326, + "sfxVE_FREXP": 1331, + "sfxVE_INJR1": 1332, + "sfxVE_INJR2": 1333, + "sfxVE_SCRC1": 1334, + "sfxVE_SCRC2": 1335, + "sfxVE_WING1": 1336, + "sfxVI_DEAT1": 1359, + "sfxVI_DEAT2": 1360, + "sfxVI_FOOT1": 1363, + "sfxVI_GRAZ1": 1367, + "sfxVI_GRAZ2": 1368, + "sfxVI_INJR1": 1371, + "sfxVI_INJR2": 1372, + "sfxVI_MOO1": 1374, + "sfxVI_MOO2": 1375, + "sfxVI_SQUI1": 1377, + "sfxVI_SQUI2": 1378, + "sfxRH_BAZOO": 1379, + "sfxRH_JPKLP": 1381, + "sfxRH_RKLCH": 1384, + "sfxRH_SPRSH": 1385, + "sfxRN_HORN": 1388, + "sfxSR_FSDI1": 1391, + "sfxSR_FSDI2": 1392, + "sfxME_BSHCL": 1393, + "sfxME_BSHDC": 1394, + "sfxME_BUSRS1": 1396, + "sfxME_CNSLP": 1397, + "sfxME_CNSND": 1398, + "sfxME_CNSST": 1399, + "sfxME_DRPWP": 1400, + "sfxME_FALL1": 1401, + "sfxME_FALL2": 1402, + "sfxME_FSDI1": 1403, + "sfxME_FSDI2": 1404, + "sfxME_FSGR1": 1405, + "sfxME_FSGR2": 1406, + "sfxME_FSMT1": 1407, + "sfxME_FSMT2": 1408, + "sfxME_FSSA1": 1409, + "sfxME_FSSA2": 1410, + "sfxME_FSSN1": 1411, + "sfxME_FSSN2": 1412, + "sfxME_FSST1": 1413, + "sfxME_FSST2": 1414, + "sfxME_FSWA1": 1415, + "sfxME_FSWA2": 1416, + "sfxME_FSWD1": 1417, + "sfxME_FSWD2": 1418, + "sfxME_FSWG1": 1419, + "sfxME_FSWG2": 1420, + "sfxME_GRNEX": 1421, + "sfxME_GRNTH": 1423, + "sfxME_GTAPP": 1424, + "sfxME_GTFR1": 1426, + "sfxME_GTLP": 1427, + "sfxME_GYDMG": 1430, + "sfxME_GYDML": 1431, + "sfxME_GYIN": 1432, + "sfxME_GYLND": 1433, + "sfxME_GYLP": 1434, + "sfxME_GYON": 1437, + "sfxME_GYOUT": 1438, + "sfxME_GYREV": 1439, + "sfxME_HDFL1": 1440, + "sfxME_HDFL2": 1441, + "sfxME_HOMEX": 1442, + "sfxME_HOMRL": 1443, + "sfxME_HOMSH": 1444, + "sfxME_HOMTA": 1445, + "sfxME_JPKEN": 1456, + "sfxME_JPKLP": 1457, + "sfxME_JPKST": 1458, + "sfxME_JPKTH": 1459, + "sfxME_JUPEN": 1461, + "sfxME_JUPLP": 1462, + "sfxME_JUPST": 1463, + "sfxME_MINEX": 1466, + "sfxME_MINHT": 1467, + "sfxME_MINLK": 1468, + "sfxME_MINML": 1469, + "sfxME_MINTH": 1471, + "sfxME_MSHEN": 1472, + "sfxME_MSHLP": 1473, + "sfxME_MSHST": 1474, + "sfxME_MSLEX": 1475, + "sfxME_MSLRL": 1476, + "sfxME_MTREX": 1478, + "sfxME_MTRHT": 1479, + "sfxME_MTRRL": 1480, + "sfxME_MTRSH": 1481, + "sfxME_OUTAM": 1484, + "sfxME_PEARL": 1485, + "sfxME_POPDN": 1486, + "sfxME_POPEX": 1487, + "sfxME_POPSH": 1488, + "sfxME_PRXEX1": 1489, + "sfxME_PRXRL": 1491, + "sfxME_PRXSH": 1492, + "sfxME_REPND": 1493, + "sfxME_REPST": 1494, + "sfxME_RSGEX": 1496, + "sfxME_RSGRL": 1497, + "sfxME_RSGSH": 1498, + "sfxME_RTAPP": 1499, + "sfxME_RTFR1": 1500, + "sfxME_RTLP": 1501, + "sfxME_RTTG": 1503, + "sfxME_SHRT1": 1504, + "sfxME_SHRT2": 1505, + "sfxME_SHRT3": 1506, + "sfxME_SLD1": 1507, + "sfxME_SMTDP": 1508, + "sfxME_SMTOF": 1509, + "sfxME_SMTON": 1510, + "sfxME_SPRRL": 1511, + "sfxME_SPRSH": 1512, + "sfxME_SPRZI": 1513, + "sfxME_SWMLP": 1515, + "sfxME_SYRNG": 1517, + "sfxME_TRRBD": 1518, + "sfxME_TRRDN": 1519, + "sfxME_TRRLP": 1521, + "sfxME_TRRSS": 1524, + "sfxME_VMPDP": 1526, + "sfxME_PEAS1": 1527, + "sfxME_PEAS2": 1528, + "sfxME_MCHEN": 1529, + "sfxME_MCHLP": 1530, + "sfxME_MCHST": 1531, + "sfxME_MCHSL": 1532, + "sfxBS_STGAT": 1533, + "sfxBS_WDGAT": 1534, + "sfxBI_DIRT1": 1536, + "sfxBI_WATR1": 1539, + "sfxCH_CRYST": 1540, + "sfxCH_ICEW1": 1541, + "sfxCH_ICEW2": 1542, + "sfxEX_BDYL1": 1543, + "sfxEX_BDYL2": 1544, + "sfxEX_BDYS1": 1547, + "sfxEX_BDYS2": 1548, + "sfxEX_DIRTS": 1549, + "sfxEX_DIRTL": 1550, + "sfxEX_METLS": 1551, + "sfxEX_METLL": 1552, + "sfxEX_ROCK": 1554, + "sfxEX_STONS": 1556, + "sfxEX_STONL": 1557, + "sfxEX_TREES": 1558, + "sfxEX_TREEL": 1559, + "sfxEX_WATRS": 1560, + "sfxEX_WATRL": 1561, + "sfxEX_WOODS": 1563, + "sfxEX_WOODL": 1564, + "sfxJS_BSPL1": 1565, + "sfxJS_BSPL2": 1566, + "sfxJS_HIDL1": 1568, + "sfxJS_HMVE1": 1569, + "sfxJS_HRVU1": 1573, + "sfxJS_RIDL1": 1574, + "sfxJS_RLND1": 1575, + "sfxJS_RLNDH": 1576, + "sfxJS_RMVE1": 1577, + "sfxJS_ROFF": 1578, + "sfxJS_RON": 1579, + "sfxJS_RRVD1": 1580, + "sfxJS_RRVU1": 1581, + "sfxJS_SPLAS": 1582, + "sfxPR_ARHOM": 1583, + "sfxPR_ARLRG": 1584, + "sfxPR_ARSML": 1585, + "sfxPR_BLHVY": 1586, + "sfxPR_BLLIT": 1587, + "sfxPR_CRLRG": 1588, + "sfxPR_CRSML": 1589, + "sfxPR_FBLRG": 1590, + "sfxPR_FBSML": 1591, + "sfxPR_WSMAG": 1592, + "sfxPR_WSMIL": 1593, + "sfxPR_WSROC": 1594, + "sfxPU_AMMO": 1595, + "sfxPU_HLTH": 1596, + "sfxPU_MEAT1": 1597, + "sfxPU_MEAT2": 1598, + "sfxSD_LGHT": 1599, + "sfxSD_LGLP": 1600, + "sfxSD_LGST": 1601, + "sfxSD_SMHT1": 1602, + "sfxSD_SMLP": 1603, + "sfxSD_SMST": 1604, + "sfxSD_LRGND": 1605, + "sfxSD_SMLND": 1606, + "sfxRL_SPAWN": 1607, + "sfxRM_SPAWN": 1608, + "sfxSM_FSLD1": 1609, + "sfxSM_FSSW1": 1610, + "sfxSE_SPLSH": 1611, + "sfxSE_FIRST": 1612, + "sfxSE_FIRND": 1613, + "sfxRH_FSLD1": 1614, + "sfxRH_FSSW1": 1615, + "sfxBB_ADSMT": 1616, + "sfxBB_BEGIN": 1617, + "sfxBB_ENTER": 1618, + "sfxBB_EXIT": 1619, + "sfxBB_NSLCT": 1620, + "sfxBB_SELCT": 1621, + "sfxBB_TKSMT": 1622, + "sfxMM_BACK": 1623, + "sfxMM_MAJOR": 1625, + "sfxMM_MINOR": 1626, + "sfxMS_BRNLP": 1627, + "sfxMS_BRNND": 1628, + "sfxMS_BRNST": 1629, + "sfxMS_ELVEN": 1630, + "sfxMS_ELVLP": 1631, + "sfxMS_ELVST": 1632, + "sfxMS_MSFTC": 1634, + "sfxMS_MSFTO": 1635, + "sfxMS_PORTD": 1636, + "sfxMS_PORTL": 1637, + "sfxMS_PORTR": 1638, + "sfxMS_TDEF1": 1639, + "sfxMS_TDEF2": 1640, + "sfxPH_AMBLP": 1641, + "sfxPH_DSLCT": 1642, + "sfxPH_ENTER": 1643, + "sfxPH_EXIT": 1644, + "sfxPH_NSLCT": 1645, + "sfxPH_SELCT": 1646, + "sfxPH_SNGL1": 1647, + "sfxPH_SNGL2": 1648, + "sfxPH_SNGL3": 1649, + "sfxPH_SNGL4": 1650, + "sfxSH_ENTER": 1651, + "sfxSH_EXIT": 1652, + "sfxSH_NSLCT": 1653, + "sfxSH_PLACE": 1654, + "sfxRH_MCHEN": 1656, + "sfxRH_MCHLP": 1657, + "sfxRH_MCHST": 1658, + "sfxRL_GENHT": 1659, + "sfxRL_GNDIE": 1660, + "sfxRS_GENHT": 1661, + "sfxRS_GNDIE": 1662, + "sfxRS_SPAWN": 1663, + "sfxME_FLARE": 1664, + "sfxME_JPKNO": 1665, + "sfxOF_CLAW1": 1666, + "sfxOF_CLAW2": 1667, + "sfxOF_DETH1": 1668, + "sfxOF_DETH2": 1669, + "sfxOF_DHIT1": 1670, + "sfxOF_DHIT2": 1671, + "sfxOF_DIVE": 1672, + "sfxOF_LNCH1": 1673, + "sfxOF_ROAR1": 1674, + "sfxOF_ROAR2": 1675, + "sfxSR_EVFLL": 1677, + "sfxSR_FLYNO": 1679, + "sfxSR_SWHT3": 1680, + "sfxSR_SWHT4": 1681, + "sfxME_REPLP": 1682, + "sfxREX002_1": 1683, + "sfxREX002_3": 1684, + "sfxREX004_3": 1685, + "sfxREX004_4": 1686, + "sfxBAZ_CT47": 1687, + "sfxGOR_CT47": 1688, + "sfxREG_CT47": 1689, + "sfxREX005_1": 1690, + "sfxREX005_2": 1691, + "sfxDEX001_1": 1692, + "sfxDEX001_4": 1693, + "sfxDEX002_4": 1694, + "sfxDEX002_6": 1695, + "sfxDEX001_6": 1696, + "sfxDEX005_1": 1697, + "sfxDEX005_2": 1698, + "sfxSAX001_5": 1699, + "sfxSAX001_3": 1700, + "sfxSAX002_2": 1701, + "sfxSAX002_3": 1702, + "sfxSAX004_1": 1703, + "sfxSAX005_2": 1704, + "sfxGSM03_1": 1705, + "sfxGSM03_2": 1706, + "sfxGSM01_1": 1707, + "sfxGSM01_2": 1708, + "sfxGSM02_1": 1709, + "sfxGSM02_2": 1710, + "sfxGSM05_1": 1711, + "sfxGSM05_2": 1712, + "sfxGSM04_1": 1713, + "sfxGSM04_2": 1714, + "sfxGSM06_1": 1715, + "sfxGSM06_2": 1716, + "sfxGSM08_1": 1717, + "sfxGSM08_2": 1718, + "sfxGSM09_1": 1719, + "sfxGSM09_2": 1720, + "sfxGSM10_1": 1721, + "sfxGSM10_2": 1722, + "sfxGSM11_1": 1723, + "sfxGSM11_2": 1724, + "sfxGSM12_1": 1725, + "sfxGSM12_2": 1726, + "sfxAM_RPSBL": 1727, + "sfxAM_BRGL1": 1728, + "sfxAM_RS32B": 1729, + "sfxAM_MS1Q": 1730, + "sfxJS_BUMP1": 1735, + "sfxJS_BUMP2": 1736, + "sfxJS_BUOY": 1737, + "sfxJS_FINIS": 1739, + "sfxJS_HMISH": 1740, + "sfxJS_HMISS": 1741, + "sfxJS_LOSE": 1742, + "sfxJS_MBUOY": 1743, + "sfxJS_SPLSH": 1746, + "sfxJS_START": 1747, + "sfxJS_TBACT": 1748, + "sfxJS_WIN": 1750, + "sfxJS_WIPO1": 1751, + "sfxKA_ADLV1": 1752, + "sfxKA_ADLV2": 1753, + "sfxKA_ADLV3": 1754, + "sfxKA_MAGZI": 1755, + "sfxKA_RNJOG": 1756, + "sfxKA_RNSPR": 1757, + "sfxPT_WING1": 1758, + "sfxMS_SPLA1": 1759, + "sfxMS_SPLA2": 1760, + "sfxKA_GROW": 1764, + "sfxME_PLACE": 1765, + "sfxMM_LOOP": 1766, + "sfxPT_SQUA1": 1767, + "sfxPT_SQUA2": 1768, + "sfxSR_PLACE": 1769, + "sfxSR_PORTL": 1770, + "sfxSR_REPLP": 1771, + "sfxSR_REPND": 1772, + "sfxSR_REPST": 1773, + "sfxSR_SPCLP": 1774, + "sfxME_MINSH": 1775, + "sfxCA_SNORT": 1776, + "sfxME_GYREO": 1777, + "sfxGSM13_1": 1778, + "sfxGSM13_2": 1779, + "sfxGSM14_1": 1780, + "sfxGSM14_2": 1781, + "sfxGSM15_1": 1782, + "sfxGSM15_2": 1783, + "sfxBAX007_1": 1784, + "sfxBAX007_2": 1785, + "sfxBI_HIT1": 1786, + "sfxBI_HIT2": 1787, + "sfxJS_BWASH": 1788, + "sfxBOR059": 1789, + "sfxBOR083": 1790, + "sfxBOR073": 1791, + "sfxBOR081": 1792, + "sfxBOR084": 1793, + "sfxBOR041": 1794, + "sfxYANCHI_2": 1797, + "sfxYANCHI_3": 1798, + "sfxYANCHI_4": 1799, + "sfxYANCHI_5": 1800, + "sfxYANCHI_7": 1801, + "sfxYANCHI_8": 1802, + "sfxYAN031_1": 1803, + "sfxYAN050": 1804, + "sfxTOB006": 1807, + "sfxTOB007": 1808, + "sfxDAD009": 1809, + "sfxDAD017": 1810, + "sfxAM_STRS1": 1811, + "sfxAM_STRS2": 1812, + "sfxAM_STRS3": 1813, + "sfxAM_STRS4": 1814, + "sfxME_SLDEN": 1815, + "sfxSR_SLDEN": 1816, + "sfxrain_heavy": 1817, + "SfxNumSounds": 2000 + }, + "Fx": { + "FxDef": 1, + "FxDone": 2, + "FxCreateObj": 3, + "FxLifeSpan": 4, + "FxLifeSpan_Range": 5, + "FxPushObj": 6, + "FxPopObj": 7, + "FxScaleLinear": 8, + "FxScaleLinear_Range": 9, + "FxAttach": 10, + "FxPause": 11, + "FxPause_Range": 12, + "FxOnDeath": 13, + "FxGravity": 14, + "FxGravity_Range": 15, + "FxStartDir": 16, + "FxStartSpeed": 17, + "FxStartSpeed_Range": 18, + "FxFriction": 19, + "FxFriction_Range": 20, + "FxOnGroundDeath": 21, + "FxOnGroundDelete": 22, + "FxHeightOffset": 23, + "FxHeightOffset_Range": 24, + "FxOnGroundReflect": 25, + "FxOnGroundReflect_Range": 26, + "FxScale": 27, + "FxScale_Range": 28, + "FxEmit": 29, + "FxEmit_Range": 30, + "FxTracer_RGB": 32, + "FxInvisible": 33, + "FxTracer_LifeSpan": 34, + "FxTracer": 35, + "FxCreateGameLockedObj": 36, + "FxTracer_Width": 37, + "FxTracer_SegTime": 38, + "FxEmitRef": 39, + "FxEmitRef_Range": 40, + "FxTextureAnimation": 41, + "FxPlaySound": 42, + "FxPlaySound_Range": 43, + "FxPlaySoundObject": 44, + "FxPlaySoundObject_Range": 45, + "FxTracer_Delay": 46, + "FxTracer_Delay_Range": 47, + "FxTracer_FadeIn": 48, + "FxTracer_FadeIn_Range": 49, + "FxRotate": 50, + "FxRotate_Range": 51, + "FxScaleExp": 52, + "FxScaleExp_Range": 53, + "FxScaleLog": 54, + "FxScaleLog_Range": 55, + "FxWeather_Create": 56, + "FxWeather_Start": 57, + "FxWeather_Distance": 58, + "FxWeather_WindLinear": 59, + "FxWeather_LifeSpan": 60, + "FxWeather_Fog": 61, + "FxWeather_WindExp": 62, + "FxWeather_WindLog": 63, + "FxUVScrolling": 64, + "FxWeather_FogSky": 65, + "FxWeather_UnfogDelay": 66, + "FxPlaySoundMono": 67, + "FxPlaySoundMono_Range": 68, + "FxCreateFlame": 69, + "FxVerticleFade": 70, + "FxTornado": 71, + "FxGameHandled": 72, + "FxLogObject": 73, + "FxWait": 74, + "FxLabel": 75, + "FxGoto": 76, + "FxOnInsert": 77, + "FxOnHome": 78, + "FxOnPageUp": 79, + "FxOnDelete": 80, + "FxOnEnd": 81, + "FxOnPageDown": 82, + "FxWeather_FogWater": 83, + "FxKillLoggedObj": 84, + "FxOnResume": 85, + "FxEmitRefLock": 86, + "FxEmitRefLock_Range": 87, + "FxStartOnGround": 88, + "FxIgnoreSlowTime": 89, + "FxOnGroundCreate": 90, + "FxEmitRefDir": 91, + "FxEmitRefDir_Range": 92, + "FxPhysicsMass": 93, + "FxPhysicsMass_Range": 94, + "FxPhysicsGravMass": 95, + "FxPhysicsGravMass_Range": 96, + "FxPhysicsInertialMass": 97, + "FxPhysicsInertialMass_Range": 98, + "FxPhysicsGroundFriction": 99, + "FxPhysicsGroundFriction_Range": 100, + "FxPhysicsElasticity": 101, + "FxPhysicsElasticity_Range": 102, + "FxPhysicsRestitution": 103, + "FxPhysicsRestitution_Range": 104, + "FxPhysicsGrndFricPwr": 105, + "FxPhysicsGrndFricPwr_Range": 106, + "FxPhysicsGrndFricPwrDOff": 107, + "FxPhysicsGrndFricPwrDOff_Range": 108, + "FxFaceDirection": 109, + "FxStopEmitter": 110, + "FxStopEmitter_Range": 111, + "FxOStartDir": 112, + "FxOEmitRefDir": 113, + "FxOEmitRefDir_Range": 114, + "FxInitialRotation": 115, + "FxInitialRotation_Range": 116, + "FxOnGroundDecal": 117, + "FxDecal": 118, + "FxOnGroundDecalObjScale": 119, + "FxDecalObjScale": 120, + "FxOrientToGround": 121, + "FxCreateLoc": 122, + "FxCollidable": 123, + "FxPlaySoundSequenceTarget": 124, + "FxPlaySoundSequenceMono": 125, + "FxInterruptSoundSequence": 126, + "FxScreenShake": 127, + "FxDrift": 128, + "FxPlaySoundSequencePlayer": 129, + "FxPlaySoundSequence": 130, + "FxPlaySoundPlayer": 131, + "FxPlayAnim": 132, + "FxEndAnim": 133, + "FxObjectCount": 134, + "FxPlaySoundPlayerNC": 135, + "FxFadeIn": 136, + "FxCreateCamera": 137, + "FxCreateObjCamera": 138, + "FxPlayForcePlayer": 139, + "FxPlayForceProximity": 140, + "FxEmitRandom": 141, + "FxEmitRandom_Range": 142, + "FxStartDirRandom": 143, + "FxEmitParticlesLoc": 144, + "FxParticleBlur": 145, + "FxParticleSize": 146, + "FxParticleFalloffSize": 147, + "FxParticleDamping": 148, + "FxParticleSpeed": 149, + "FxParticleLifeSpan": 150, + "FxParticleConeAngle": 151, + "FxEmitParticlesObj": 152, + "FxEmitParticlesRef": 153, + "FxEmitParticles": 154, + "FxWeather_Emit": 155, + "FxWeather_CreateWind": 156, + "FxWindScreen": 157, + "FxWeather_Intervals": 158, + "FxWeather_Fill": 159, + "FxCreateLight": 160, + "FxWeather_FogDist": 161, + "FxWeather_FogWaterDist": 162, + "FxShaderSet": 163, + "FxShaderSetTexture": 164, + "FxScreenFlash": 165 + } + } + }, + "MacroDefinitions": { + "2": { + "Opcode": 2, + "Name": "fxdone", + "FxDefGroup": [] + }, + "3": { + "Opcode": 3, + "Name": "createobj", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "ObjObj", + "ArgumentIndex": 1 + } + ] + }, + "4": { + "Opcode": 4, + "Name": "lifespan", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": "0.0", + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 0 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "5": { + "Opcode": 5, + "Name": "lifespan", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": "0.0", + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 0 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": "0.0", + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 0 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "6": { + "Opcode": 6, + "Name": "pushobj", + "FxDefGroup": [] + }, + "7": { + "Opcode": 7, + "Name": "popobj", + "FxDefGroup": [] + }, + "8": { + "Opcode": 8, + "Name": "scale_linear", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "9": { + "Opcode": 9, + "Name": "scale_linear", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "10": { + "Opcode": 10, + "Name": "attach", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "11": { + "Opcode": 11, + "Name": "pause", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "12": { + "Opcode": 12, + "Name": "pause", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "13": { + "Opcode": 13, + "Name": "ondeath", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "14": { + "Opcode": 14, + "Name": "gravity", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "15": { + "Opcode": 15, + "Name": "gravity", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "16": { + "Opcode": 16, + "Name": "startdir", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "17": { + "Opcode": 17, + "Name": "speed", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "18": { + "Opcode": 18, + "Name": "speed", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "19": { + "Opcode": 19, + "Name": "friction", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "20": { + "Opcode": 20, + "Name": "friction", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "21": { + "Opcode": 21, + "Name": "ongrounddeath", + "FxDefGroup": [] + }, + "22": { + "Opcode": 22, + "Name": "ongrounddelete", + "FxDefGroup": [] + }, + "23": { + "Opcode": 23, + "Name": "heightoffset", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "24": { + "Opcode": 24, + "Name": "heightoffset", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "25": { + "Opcode": 25, + "Name": "ongroundreflect", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "26": { + "Opcode": 26, + "Name": "ongroundreflect", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "27": { + "Opcode": 27, + "Name": "scale", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "28": { + "Opcode": 28, + "Name": "scale", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "29": { + "Opcode": 29, + "Name": "emit", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "30": { + "Opcode": 30, + "Name": "emit", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "32": { + "Opcode": 32, + "Name": "tracer_rgb", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + } + ] + }, + "33": { + "Opcode": 33, + "Name": "invisible", + "FxDefGroup": [] + }, + "34": { + "Opcode": 34, + "Name": "tracer_lifespan", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "35": { + "Opcode": 35, + "Name": "tracer", + "FxDefGroup": [] + }, + "36": { + "Opcode": 36, + "Name": "creategamelockedobj", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "ObjObj", + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "ObjObj", + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "37": { + "Opcode": 37, + "Name": "tracer_width", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "38": { + "Opcode": 38, + "Name": "tracer_segtime", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "39": { + "Opcode": 39, + "Name": "emitref", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "40": { + "Opcode": 40, + "Name": "emitref", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + } + ] + }, + "41": { + "Opcode": 41, + "Name": "textureanimation", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "42": { + "Opcode": 42, + "Name": "playsound", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 1 + } + ] + }, + "43": { + "Opcode": 43, + "Name": "playsound", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 2 + } + ] + }, + "44": { + "Opcode": 44, + "Name": "playsoundobject", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 1 + } + ] + }, + "45": { + "Opcode": 45, + "Name": "playsoundobject", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 2 + } + ] + }, + "46": { + "Opcode": 46, + "Name": "tracer_delay", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "47": { + "Opcode": 47, + "Name": "tracer_delay", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "48": { + "Opcode": 48, + "Name": "tracer_fadein", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "49": { + "Opcode": 49, + "Name": "tracer_fadein", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "50": { + "Opcode": 50, + "Name": "rotate", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "51": { + "Opcode": 51, + "Name": "rotate", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + } + ] + }, + "52": { + "Opcode": 52, + "Name": "scale_exp", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "53": { + "Opcode": 53, + "Name": "scale_exp", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "54": { + "Opcode": 54, + "Name": "scale_log", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "55": { + "Opcode": 55, + "Name": "scale_log", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "56": { + "Opcode": 56, + "Name": "createweather", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "ObjObj", + "ArgumentIndex": 1 + } + ] + }, + "57": { + "Opcode": 57, + "Name": "weather_start", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "58": { + "Opcode": 58, + "Name": "weather_distance", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "59": { + "Opcode": 59, + "Name": "wind_linear", + "FxDefGroup": [] + }, + "60": { + "Opcode": 60, + "Name": "weather_lifespan", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "61": { + "Opcode": 61, + "Name": "weather_fog", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + } + ] + }, + "62": { + "Opcode": 62, + "Name": "wind_exp", + "FxDefGroup": [] + }, + "63": { + "Opcode": 63, + "Name": "wind_log", + "FxDefGroup": [] + }, + "64": { + "Opcode": 64, + "Name": "uvscroll", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "65": { + "Opcode": 65, + "Name": "weather_fog_sky", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 7 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 8 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 9 + } + ] + }, + "66": { + "Opcode": 66, + "Name": "weather_unfog_delay", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "67": { + "Opcode": 67, + "Name": "playsoundmono", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "68": { + "Opcode": 68, + "Name": "playsoundmono", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "69": { + "Opcode": 69, + "Name": "createflame", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "70": { + "Opcode": 70, + "Name": "verticlefade", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + } + ] + }, + "71": { + "Opcode": 71, + "Name": "tornado", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "72": { + "Opcode": 72, + "Name": "gamehandled", + "FxDefGroup": [] + }, + "73": { + "Opcode": 73, + "Name": "logobject", + "FxDefGroup": [] + }, + "74": { + "Opcode": 74, + "Name": "wait", + "FxDefGroup": [] + }, + "75": { + "Opcode": 75, + "Name": "label", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "76": { + "Opcode": 76, + "Name": "goto", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "77": { + "Opcode": 77, + "Name": "oninsert", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "78": { + "Opcode": 78, + "Name": "onhome", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "79": { + "Opcode": 79, + "Name": "onpageup", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "80": { + "Opcode": 80, + "Name": "ondelete", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "81": { + "Opcode": 81, + "Name": "onend", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "82": { + "Opcode": 82, + "Name": "onpagedown", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "83": { + "Opcode": 83, + "Name": "weather_fog_water", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + } + ] + }, + "84": { + "Opcode": 84, + "Name": "killloggedobj", + "FxDefGroup": [] + }, + "85": { + "Opcode": 85, + "Name": "onresume", + "FxDefGroup": [] + }, + "86": { + "Opcode": 86, + "Name": "emitreflock", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "87": { + "Opcode": 87, + "Name": "emitreflock", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 7 + } + ] + }, + "88": { + "Opcode": 88, + "Name": "startonground", + "FxDefGroup": [] + }, + "89": { + "Opcode": 89, + "Name": "ignoreslowtime", + "FxDefGroup": [] + }, + "90": { + "Opcode": 90, + "Name": "ongroundcreate", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "91": { + "Opcode": 91, + "Name": "emitrefdir", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "92": { + "Opcode": 92, + "Name": "emitrefdir", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 7 + } + ] + }, + "93": { + "Opcode": 93, + "Name": "mass", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "94": { + "Opcode": 94, + "Name": "mass", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "95": { + "Opcode": 95, + "Name": "gravitationalmass", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "96": { + "Opcode": 96, + "Name": "gravitationalmass", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "97": { + "Opcode": 97, + "Name": "inertialmass", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "98": { + "Opcode": 98, + "Name": "inertialmass", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "99": { + "Opcode": 99, + "Name": "groundfrictionlimit", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "100": { + "Opcode": 100, + "Name": "groundfrictionlimit", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "101": { + "Opcode": 101, + "Name": "elasticity", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "102": { + "Opcode": 102, + "Name": "elasticity", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "103": { + "Opcode": 103, + "Name": "restitution", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "104": { + "Opcode": 104, + "Name": "restitution", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "105": { + "Opcode": 105, + "Name": "groundfriction", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "106": { + "Opcode": 106, + "Name": "groundfriction", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "107": { + "Opcode": 107, + "Name": "groundfrictiondoff", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "108": { + "Opcode": 108, + "Name": "groundfrictiondoff", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "109": { + "Opcode": 109, + "Name": "facedirection", + "FxDefGroup": [] + }, + "110": { + "Opcode": 110, + "Name": "stopemitter", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "111": { + "Opcode": 111, + "Name": "stopemitter", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "112": { + "Opcode": 112, + "Name": "ostartdir", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "113": { + "Opcode": 113, + "Name": "oemitrefdir", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "114": { + "Opcode": 114, + "Name": "oemitrefdir", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 7 + } + ] + }, + "115": { + "Opcode": 115, + "Name": "initialrotation", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "116": { + "Opcode": 116, + "Name": "initialrotation", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + } + ] + }, + "117": { + "Opcode": 117, + "Name": "ongrounddecal", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "118": { + "Opcode": 118, + "Name": "decal", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "119": { + "Opcode": 119, + "Name": "ongrounddecalobjscale", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "120": { + "Opcode": 120, + "Name": "decalobjscale", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "121": { + "Opcode": 121, + "Name": "orienttoground", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "122": { + "Opcode": 122, + "Name": "fxcreate", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 7 + } + ] + }, + "123": { + "Opcode": 123, + "Name": "collidable", + "FxDefGroup": [] + }, + "124": { + "Opcode": 124, + "Name": "playsoundsequencetarget", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + } + ] + }, + "126": { + "Opcode": 126, + "Name": "interruptsoundsequence", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "127": { + "Opcode": 127, + "Name": "screenshake", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "128": { + "Opcode": 128, + "Name": "drift", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "129": { + "Opcode": 129, + "Name": "playsoundsequenceplayer", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + } + ] + }, + "131": { + "Opcode": 131, + "Name": "playsoundplayer", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 1 + } + ] + }, + "132": { + "Opcode": 132, + "Name": "playanim", + "FxDefGroup": [] + }, + "133": { + "Opcode": 133, + "Name": "endanim", + "FxDefGroup": [] + }, + "135": { + "Opcode": 135, + "Name": "playsoundplayernc", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "Sfx", + "ArgumentIndex": 1 + } + ] + }, + "136": { + "Opcode": 136, + "Name": "fadein", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "137": { + "Opcode": 137, + "Name": "fxcreate_camera", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "138": { + "Opcode": 138, + "Name": "createobj_camera", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "ObjObj", + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "139": { + "Opcode": 139, + "Name": "playforceplayer", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "FF_", + "ArgumentIndex": 1 + } + ] + }, + "140": { + "Opcode": 140, + "Name": "playforceproximity", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": "FF_", + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "141": { + "Opcode": 141, + "Name": "emitrefdirrandom", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 7 + } + ] + }, + "142": { + "Opcode": 142, + "Name": "emitrefdirrandom", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 7 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 8 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 9 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 10 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 11 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 12 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 13 + } + ] + }, + "143": { + "Opcode": 143, + "Name": "startdirrandom", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 6 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 7 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 8 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 9 + } + ] + }, + "144": { + "Opcode": 144, + "Name": "emitparticlesloc", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "145": { + "Opcode": 145, + "Name": "particleblur", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "146": { + "Opcode": 146, + "Name": "particlesize", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "147": { + "Opcode": 147, + "Name": "particlefalloffsize", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "148": { + "Opcode": 148, + "Name": "particledamping", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "149": { + "Opcode": 149, + "Name": "particlespeed", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "150": { + "Opcode": 150, + "Name": "particlelifespan", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "151": { + "Opcode": 151, + "Name": "particleconeangle", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "152": { + "Opcode": 152, + "Name": "emitparticlesobj", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "153": { + "Opcode": 153, + "Name": "emitparticlesref", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "154": { + "Opcode": 154, + "Name": "emitparticles", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "155": { + "Opcode": 155, + "Name": "weather_emit", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "156": { + "Opcode": 156, + "Name": "createwind", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "157": { + "Opcode": 157, + "Name": "wind_screen", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "158": { + "Opcode": 158, + "Name": "weather_intervals", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + }, + "159": { + "Opcode": 159, + "Name": "weather_fill", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "160": { + "Opcode": 160, + "Name": "createlight", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "db", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "db", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "db", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 5 + } + ] + }, + "161": { + "Opcode": 161, + "Name": "weather_fog_dist", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "162": { + "Opcode": 162, + "Name": "weather_fog_water_dist", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + } + ] + }, + "163": { + "Opcode": 163, + "Name": "shaderset", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + } + ] + }, + "164": { + "Opcode": 164, + "Name": "shadersettexture", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "name0cs", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + } + ] + }, + "165": { + "Opcode": 165, + "Name": "screenflash", + "FxDefGroup": [ + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 1 + }, + { + "Type": 1, + "Instruction": "dl", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 2 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 3 + }, + { + "Type": 1, + "Instruction": "df", + "Constant": null, + "ConstantName": null, + "ArgumentPrefix": null, + "ArgumentIndex": 4 + } + ] + } + } +} \ No newline at end of file diff --git a/Giants.EffectCompiler/FxBinaryData.cs b/Giants.EffectCompiler/FxBinaryData.cs new file mode 100644 index 0000000..b4e0a8e --- /dev/null +++ b/Giants.EffectCompiler/FxBinaryData.cs @@ -0,0 +1,33 @@ +namespace Giants.EffectCompiler +{ + using System; + using System.IO; + + public class FxBinaryData + { + public const int CurrentVersion = 2; + + public int Version { get; private set; } + + public int DataSize { get; private set; } + + public int EffectCount { get; private set; } + + public byte[] Data { get; private set; } + + public FxBinaryData(Stream stream) + { + using var reader = new BinaryReader(stream); + + this.Version = reader.ReadInt32(); + if (this.Version != CurrentVersion) + { + throw new ArgumentException("The version number is incorrect."); + } + + this.DataSize = reader.ReadInt32(); + this.EffectCount = reader.ReadInt32(); + this.Data = reader.ReadBytes(this.DataSize); + } + } +} diff --git a/Giants.EffectCompiler/FxMacroDefinition.cs b/Giants.EffectCompiler/FxMacroDefinition.cs new file mode 100644 index 0000000..60082f8 --- /dev/null +++ b/Giants.EffectCompiler/FxMacroDefinition.cs @@ -0,0 +1,14 @@ +namespace Giants.EffectCompiler +{ + using System.Collections.Generic; + using Giants.BinTools.Macro; + + public class FxMacroDefinition + { + public int Opcode { get; set; } + + public string Name { get; set; } + + public IEnumerable FxDefGroup { get; set; } + } +} diff --git a/Giants.EffectCompiler/FxMacroDefinitionTable.cs b/Giants.EffectCompiler/FxMacroDefinitionTable.cs new file mode 100644 index 0000000..f749140 --- /dev/null +++ b/Giants.EffectCompiler/FxMacroDefinitionTable.cs @@ -0,0 +1,161 @@ +namespace Giants.EffectCompiler +{ + using System; + using System.Collections.Generic; + using System.Linq; + using Giants.BinTools.Macro; + using Giants.BinTools.Symbol; + using Newtonsoft.Json; + using NLog; + + public class FxMacroDefinitionTable + { + private static readonly Logger logger = LogManager.GetLogger(nameof(FxMacroDefinitionTable)); + + [JsonProperty] + public SymbolTable SymbolTable { get; } = new SymbolTable(); + + [JsonProperty] + public IDictionary MacroDefinitions { get; } = new Dictionary(); + + public FxMacroDefinitionTable(MacroDefinitionTable macroDefinitionTable) + { + this.SymbolTable = macroDefinitionTable.SymbolTable; + + this.ProcessMacroDefinitions(macroDefinitionTable.MacroDefinitions); + } + + [JsonConstructor] + internal FxMacroDefinitionTable() { } + + private void ProcessMacroDefinitions(IList macroDefinitions) + { + // Try to map each opcode we know about to a pre-processed form of the macro definition with conditional branches eliminated + foreach (int opcode in this.SymbolTable.GetSymbolGroup(KnownSymbolGroupNames.Fx).Values) + { + FxMacroDefinition fxMacroDefinition = this.GetFxMacroDefinition(macroDefinitions, opcode); + if (fxMacroDefinition != null) + { + this.MacroDefinitions[opcode] = fxMacroDefinition; + } + else + { + logger.Warn($"Opcode {opcode} has no macro defined"); + } + } + } + + private FxMacroDefinition GetFxMacroDefinition(IList macroDefinitions, int opcode) + { + foreach (var macroDefinition in macroDefinitions + .Where(x => x.Groups.ContainsKey(KnownMacroGroupNames.FxDefGroup) && x.Groups[KnownMacroGroupNames.FxDefGroup].Any())) + { + var fxDefGroup = macroDefinition.Groups[KnownMacroGroupNames.FxDefGroup]; + for (int lineIndex = 0; lineIndex < fxDefGroup.Count; lineIndex++) + { + if (!(fxDefGroup[lineIndex] is DataDefinitionMacroLine line)) + { + continue; + } + + if (!string.IsNullOrEmpty(line.ConstantName) + && Convert.ToInt32(line.Constant) == opcode) + { + logger.Debug($"Matched opcode {opcode} to '{line.ConstantName}'"); + return new FxMacroDefinition + { + Opcode = opcode, + Name = macroDefinition.Name, + FxDefGroup = SelectOptimalBranch(fxDefGroup.Skip(lineIndex + 1).ToList()).ToList() + }; + + // TODO: Handle macros with instructions after the conditional (if they exist) + } + } + } + + return null; + } + + private static IEnumerable SelectOptimalBranch(List macroLines) + { + var outLines = new List(); + + int startIndex = 0; + while (startIndex < macroLines.Count) + { + if (!IsConditional(macroLines[startIndex])) + { + outLines.Add(macroLines[startIndex]); + } + else + { + break; + } + + startIndex++; + } + + if (startIndex == macroLines.Count) + { + // No branches + return outLines; + } + + int longestBranchLength = 0; + int branchIndex = startIndex; + IEnumerable branchLines = null; + while (branchIndex >= 0) + { + var argSet = new HashSet(); + + int endIndex = 0; + for (int i = branchIndex + 1; i < macroLines.Count; i++) + { + if (IsOpcodeDefinition(macroLines[i])) + { + return outLines; + } + + if (IsConditional(macroLines[i])) + { + endIndex = i; + break; + } + + if (macroLines[i] is DataDefinitionMacroLine dataDefinitionLine) + { + argSet.Add(dataDefinitionLine.ArgumentIndex); + } + } + + if (argSet.Count > longestBranchLength) + { + longestBranchLength = branchIndex; + branchLines = macroLines.Skip(branchIndex + 1).Take(endIndex - branchIndex - 1); + } + + branchIndex = macroLines.FindIndex(branchIndex + 1, l => l is IfMacroLine || l is ElseMacroLine); + } + + if (branchLines != null) + { + outLines.AddRange(branchLines); + } + + return outLines; + } + + private static bool IsOpcodeDefinition(MacroLine line) + { + return line is DataDefinitionMacroLine dataDefinitionMacroLine + && !string.IsNullOrWhiteSpace(dataDefinitionMacroLine.ConstantName) + && !string.IsNullOrWhiteSpace(dataDefinitionMacroLine.Constant); + } + + private static bool IsConditional(MacroLine line) + { + return line is IfMacroLine || line is ElseMacroLine || line is EndIfMacroLine; + } + } +} diff --git a/Giants.EffectCompiler/Giants.EffectCompiler.csproj b/Giants.EffectCompiler/Giants.EffectCompiler.csproj new file mode 100644 index 0000000..778f83f --- /dev/null +++ b/Giants.EffectCompiler/Giants.EffectCompiler.csproj @@ -0,0 +1,37 @@ + + + + netcoreapp3.1 + fxbc + Exe + + + + 1701;1702;1591 + + + + + + + + + + + + + + + + + + + + + + + PreserveNewest + + + + diff --git a/Giants.EffectCompiler/NLog.config b/Giants.EffectCompiler/NLog.config new file mode 100644 index 0000000..703d70b --- /dev/null +++ b/Giants.EffectCompiler/NLog.config @@ -0,0 +1,12 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/Giants.EffectCompiler/Program.cs b/Giants.EffectCompiler/Program.cs new file mode 100644 index 0000000..26dca4b --- /dev/null +++ b/Giants.EffectCompiler/Program.cs @@ -0,0 +1,49 @@ +namespace Giants.EffectCompiler +{ + using System; + using System.IO; + using System.Reflection; + using Giants.BinTools.Macro; + using Newtonsoft.Json; + + public class Program + { + /// + /// + /// + /// The mode to operate in. Supported modes are: 'decompile', 'compile'. + /// The input path. + /// The output path. + /// The path to the definitions file. + public static void Main(string mode, string input, string output, string definitionsPath) + { + if (string.IsNullOrEmpty(mode)) + { + Console.WriteLine("--mode is required. Type --help for example usage."); + return; + } + + switch (mode.ToLowerInvariant()) + { + case "generatedefinitions": + MacroDefinitionTable macroDefinitionTable = MacroDefinitionTable.GenerateFromLegacyBuildSystem(bldFilePath: input); + FxMacroDefinitionTable fxMacroDefinitionTable = new FxMacroDefinitionTable(macroDefinitionTable); + string serializedDefintions = JsonConvert.SerializeObject(fxMacroDefinitionTable, Formatting.Indented); + File.WriteAllText(output, serializedDefintions); + break; + case "decompile": + var decompiler = new FxDecompiler(Utilities.LoadDefinitions(definitionsPath)); + decompiler.Decompile( + inputPath: input, + outputPath: output); + break; + case "compile": + var compiler = new FxCompiler(Utilities.LoadDefinitions(definitionsPath)); + compiler.Compile( + inputPath: input, + outputPath: output); + break; + } + } + } +} diff --git a/Giants.EffectCompiler/Utilities.cs b/Giants.EffectCompiler/Utilities.cs new file mode 100644 index 0000000..0dfd3e5 --- /dev/null +++ b/Giants.EffectCompiler/Utilities.cs @@ -0,0 +1,49 @@ +namespace Giants.EffectCompiler +{ + using System; + using System.IO; + using System.Reflection; + using Giants.BinTools.Macro; + using Giants.BinTools.Symbol; + using Newtonsoft.Json; + + public static class Utilities + { + public static readonly string[] SplitCharacters = new string[] { " ", "\t" }; + + /// + /// Gets the symbolic value of an FX name. + /// + public static int GetFxSymbolValue(SymbolTable symbolTable, string symbolName) + { + if (!symbolTable.TryGetSymbolFromName( + KnownSymbolGroupNames.Fx, + symbolName, + out int symbolValue)) + { + throw new InvalidOperationException($"No symbol definition for '{symbolName}' found"); + } + + return symbolValue; + } + + public static FxMacroDefinitionTable LoadDefinitions(string definitionPath = null) + { + if (string.IsNullOrEmpty(definitionPath)) + { + using var definitionStream = Assembly.GetExecutingAssembly().GetManifestResourceStream($"{typeof(Program).Namespace}.Definitions.json"); + if (definitionStream == null) + { + throw new InvalidOperationException("Could not load the definition resource."); + } + + using var streamReader = new StreamReader(definitionStream); + string serializedTable = streamReader.ReadToEnd(); + return JsonConvert.DeserializeObject(serializedTable); + } + + MacroDefinitionTable macroDefinitionTable = MacroDefinitionTable.GenerateFromLegacyBuildSystem(bldFilePath: definitionPath); + return new FxMacroDefinitionTable(macroDefinitionTable); + } + } +} diff --git a/Giants.WebApi/Controllers/ServersController.cs b/Giants.WebApi/Controllers/ServersController.cs index e83ae42..a0ee4f0 100644 --- a/Giants.WebApi/Controllers/ServersController.cs +++ b/Giants.WebApi/Controllers/ServersController.cs @@ -59,7 +59,7 @@ namespace Giants.Web.Controllers .ToList(); string requestIpAddress = this.GetRequestIpAddress(); - logger.LogInformation("Returning {Count} servers to {IPAddress}", mappedServers.Count, requestIpAddress); + this.logger.LogInformation("Returning {Count} servers to {IPAddress}", mappedServers.Count, requestIpAddress); return mappedServers; } @@ -73,7 +73,7 @@ namespace Giants.Web.Controllers this.logger.LogInformation("Request to add server from {IPAddress}", requestIpAddress); - var serverInfoEntity = mapper.Map(serverInfo); + var serverInfoEntity = this.mapper.Map(serverInfo); serverInfoEntity.HostIpAddress = requestIpAddress.ToString(); serverInfoEntity.LastHeartbeat = DateTime.UtcNow; diff --git a/Giants.WebApi/Controllers/VersionController.cs b/Giants.WebApi/Controllers/VersionController.cs index b62f39d..f4ceb11 100644 --- a/Giants.WebApi/Controllers/VersionController.cs +++ b/Giants.WebApi/Controllers/VersionController.cs @@ -25,7 +25,7 @@ namespace Giants.WebApi.Controllers { Services.VersionInfo versionInfo = await this.updaterService.GetVersionInfo(appName); - return mapper.Map(versionInfo); + return this.mapper.Map(versionInfo); } } } diff --git a/Giants.WebApi/Giants.WebApi.csproj b/Giants.WebApi/Giants.WebApi.csproj index a9a0207..6f68da8 100644 --- a/Giants.WebApi/Giants.WebApi.csproj +++ b/Giants.WebApi/Giants.WebApi.csproj @@ -10,6 +10,7 @@ + diff --git a/Giants.WebApi/Startup.cs b/Giants.WebApi/Startup.cs index 7ac4052..7ae9456 100644 --- a/Giants.WebApi/Startup.cs +++ b/Giants.WebApi/Startup.cs @@ -14,7 +14,7 @@ namespace Giants.Web { public Startup(IConfiguration configuration) { - Configuration = configuration; + this.Configuration = configuration; } public IConfiguration Configuration { get; } @@ -29,7 +29,7 @@ namespace Giants.Web services.AddHttpContextAccessor(); services.TryAddSingleton(); - ServicesModule.RegisterServices(services, Configuration); + ServicesModule.RegisterServices(services, this.Configuration); IMapper mapper = Services.Mapper.GetMapper(); services.AddSingleton(mapper); diff --git a/GiantsTools.sln b/GiantsTools.sln index 25cd403..3dc81dc 100644 --- a/GiantsTools.sln +++ b/GiantsTools.sln @@ -15,6 +15,12 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Giants.WebApi.Clients", "Gi EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Shaders", "Shaders\Shaders.vcxproj", "{9A0AF60B-3C3B-45B7-B5E1-4C9997A68EBB}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Giants.BinTools", "Giants.BinTools\Giants.BinTools.csproj", "{6286A2C7-15F0-4D87-B928-4B012F9E0FFE}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Giants.EffectCompiler", "Giants.EffectCompiler\Giants.EffectCompiler.csproj", "{F5F3D216-9787-4CFF-88DF-8259CF667F88}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Giants.EffectCompiler.Tests", "Giants.EffectCompiler.Tests\Giants.EffectCompiler.Tests.csproj", "{49423BA5-4A9F-47A3-9D2D-E83936272DD0}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -95,6 +101,42 @@ Global {9A0AF60B-3C3B-45B7-B5E1-4C9997A68EBB}.Release|x64.Build.0 = Release|x64 {9A0AF60B-3C3B-45B7-B5E1-4C9997A68EBB}.Release|x86.ActiveCfg = Release|Win32 {9A0AF60B-3C3B-45B7-B5E1-4C9997A68EBB}.Release|x86.Build.0 = Release|Win32 + {6286A2C7-15F0-4D87-B928-4B012F9E0FFE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6286A2C7-15F0-4D87-B928-4B012F9E0FFE}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6286A2C7-15F0-4D87-B928-4B012F9E0FFE}.Debug|x64.ActiveCfg = Debug|Any CPU + {6286A2C7-15F0-4D87-B928-4B012F9E0FFE}.Debug|x64.Build.0 = Debug|Any CPU + {6286A2C7-15F0-4D87-B928-4B012F9E0FFE}.Debug|x86.ActiveCfg = Debug|Any CPU + {6286A2C7-15F0-4D87-B928-4B012F9E0FFE}.Debug|x86.Build.0 = Debug|Any CPU + {6286A2C7-15F0-4D87-B928-4B012F9E0FFE}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6286A2C7-15F0-4D87-B928-4B012F9E0FFE}.Release|Any CPU.Build.0 = Release|Any CPU + {6286A2C7-15F0-4D87-B928-4B012F9E0FFE}.Release|x64.ActiveCfg = Release|Any CPU + {6286A2C7-15F0-4D87-B928-4B012F9E0FFE}.Release|x64.Build.0 = Release|Any CPU + {6286A2C7-15F0-4D87-B928-4B012F9E0FFE}.Release|x86.ActiveCfg = Release|Any CPU + {6286A2C7-15F0-4D87-B928-4B012F9E0FFE}.Release|x86.Build.0 = Release|Any CPU + {F5F3D216-9787-4CFF-88DF-8259CF667F88}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F5F3D216-9787-4CFF-88DF-8259CF667F88}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F5F3D216-9787-4CFF-88DF-8259CF667F88}.Debug|x64.ActiveCfg = Debug|Any CPU + {F5F3D216-9787-4CFF-88DF-8259CF667F88}.Debug|x64.Build.0 = Debug|Any CPU + {F5F3D216-9787-4CFF-88DF-8259CF667F88}.Debug|x86.ActiveCfg = Debug|Any CPU + {F5F3D216-9787-4CFF-88DF-8259CF667F88}.Debug|x86.Build.0 = Debug|Any CPU + {F5F3D216-9787-4CFF-88DF-8259CF667F88}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F5F3D216-9787-4CFF-88DF-8259CF667F88}.Release|Any CPU.Build.0 = Release|Any CPU + {F5F3D216-9787-4CFF-88DF-8259CF667F88}.Release|x64.ActiveCfg = Release|Any CPU + {F5F3D216-9787-4CFF-88DF-8259CF667F88}.Release|x64.Build.0 = Release|Any CPU + {F5F3D216-9787-4CFF-88DF-8259CF667F88}.Release|x86.ActiveCfg = Release|Any CPU + {F5F3D216-9787-4CFF-88DF-8259CF667F88}.Release|x86.Build.0 = Release|Any CPU + {49423BA5-4A9F-47A3-9D2D-E83936272DD0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {49423BA5-4A9F-47A3-9D2D-E83936272DD0}.Debug|Any CPU.Build.0 = Debug|Any CPU + {49423BA5-4A9F-47A3-9D2D-E83936272DD0}.Debug|x64.ActiveCfg = Debug|Any CPU + {49423BA5-4A9F-47A3-9D2D-E83936272DD0}.Debug|x64.Build.0 = Debug|Any CPU + {49423BA5-4A9F-47A3-9D2D-E83936272DD0}.Debug|x86.ActiveCfg = Debug|Any CPU + {49423BA5-4A9F-47A3-9D2D-E83936272DD0}.Debug|x86.Build.0 = Debug|Any CPU + {49423BA5-4A9F-47A3-9D2D-E83936272DD0}.Release|Any CPU.ActiveCfg = Release|Any CPU + {49423BA5-4A9F-47A3-9D2D-E83936272DD0}.Release|Any CPU.Build.0 = Release|Any CPU + {49423BA5-4A9F-47A3-9D2D-E83936272DD0}.Release|x64.ActiveCfg = Release|Any CPU + {49423BA5-4A9F-47A3-9D2D-E83936272DD0}.Release|x64.Build.0 = Release|Any CPU + {49423BA5-4A9F-47A3-9D2D-E83936272DD0}.Release|x86.ActiveCfg = Release|Any CPU + {49423BA5-4A9F-47A3-9D2D-E83936272DD0}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE