public static Stream OpenFile(string filename)
{
if (usingLocalAPI)
{
var response = Client.GetAsync("http://" + CASCToolHostURL + "/casc/file/fname?buildconfig=" + BuildConfig + "&cdnconfig=" + CDNConfig + "&filename=" + filename);
return(response.Result.Content.ReadAsStreamAsync().Result);
}
else
{
return(cascHandler.OpenFile(filename));
}
}
public static Stream GetFile(string from)
{
try
{
return(_casc.OpenFile(from));
}
catch
{
if (!from.Contains(".adt"))
{
Console.WriteLine("Problem: " + from);
}
return(null);
}
}
public static void Load_hTextures(CASCHandler Handler)
{
if (ADTTexData.textureBlockData.MTXP)
{
ADTTexData.textureBlockData.terrainHTextures = new Dictionary <uint, ADTTexData.Texture2Ddata>();
foreach (uint TextureFileDataId in ADTTexData.textureBlockData.terrainTextureFileDataIds)
{
using (var stream = Handler.OpenFile(TextureFileDataId))
{
BLP blp = new BLP();
byte[] data = blp.GetUncompressed(stream, true);
BLPinfo info = blp.Info();
ADTTexData.Texture2Ddata texture2Ddata = new ADTTexData.Texture2Ddata();
texture2Ddata.hasMipmaps = info.hasMipmaps;
texture2Ddata.width = info.width;
texture2Ddata.height = info.height;
if (info.width != info.height) // Unity doesn't support nonsquare mipmaps // sigh
{
texture2Ddata.hasMipmaps = false;
}
texture2Ddata.textureFormat = info.textureFormat;
texture2Ddata.TextureData = data;
ADTTexData.textureBlockData.terrainHTextures.Add(TextureFileDataId, texture2Ddata);
stream.Close();
}
}
}
}
public bool LoadFile(CASCHandler cascHandler, uint fileDataId, string description)
{
var file = cascHandler.OpenFile((int)fileDataId);
if (file == null)
{
return(false);
}
var fileSize = file.Length;
if (fileSize == 0xFFFFFFFF)
{
return(false);
}
dataSize = (uint)fileSize;
data = new BinaryReader(file).ReadBytes((int)dataSize);
ParseChunks();
if (PrepareLoadedData())
{
return(true);
}
Console.WriteLine($"Error loading {description}\n");
return(false);
}
public Stream OpenFile(ApplicationPackageManifest.Types.PackageRecord record)
{
long offset = 0;
EncodingEntry enc;
if (record.Flags.HasFlag(ContentFlags.Bundle))
{
offset = record.Offset;
}
if (!CASC.EncodingHandler.GetEntry(record.LoadHash, out enc))
{
return(null);
}
MemoryStream ms = new MemoryStream((int)record.Size);
try {
Stream fstream = CASC.OpenFile(enc.Key);
fstream.Position = offset;
fstream.CopyBytes(ms, (int)record.Size);
ms.Position = 0;
} catch (Exception e) {
if (e is BLTEKeyException exception)
{
Debugger.Log(0, "DataTool", $"[DataTool:CASC]: Missing key: {exception.MissingKey:X16}\r\n");
}
return(null);
}
return(ms);
}
public static void ReadTXID(BinaryReader br, M2Data m2Data, CASCHandler CascHandler, uint Size)
{
LoadedBLPFileDataIds.Clear();
var numTextures = Size / 4;
for (int i = 0; i < numTextures; i++)
{
uint texture = br.ReadUInt32();
M2Texture m2Texture = new M2Texture();
Texture2Ddata texture2Ddata = new Texture2Ddata();
if (!LoadedBLPFileDataIds.Contains(texture))
{
var stream = CascHandler.OpenFile(texture);
BLP blp = new BLP();
byte[] data = blp.GetUncompressed(stream, true);
BLPinfo info = blp.Info();
texture2Ddata.hasMipmaps = info.hasMipmaps;
texture2Ddata.width = info.width;
texture2Ddata.height = info.height;
texture2Ddata.textureFormat = info.textureFormat;
texture2Ddata.TextureData = data;
m2Texture.texture2Ddata = texture2Ddata;
m2Texture.FileDataId = texture;
stream.Close();
stream.Dispose();
LoadedBLPFileDataIds.Add(texture);
}
m2Data.m2Tex.Add(m2Texture);
}
}
public static Stream OpenFile(uint fileDataId)
{
if (!Directory.Exists("Cache"))
{
Directory.CreateDirectory("Cache");
}
if (File.Exists($"Cache/{fileDataId}"))
{
var stream = File.Open($"Cache/{fileDataId}", FileMode.Open, FileAccess.Read, FileShare.Read);
return(stream);
}
else if (cascHandler.FileExists((int)fileDataId))
{
var stream = cascHandler.OpenFile((int)fileDataId);
var buffer = new byte[stream.Length];
// Read the data and save the file.
stream.Read(buffer, 0, buffer.Length);
File.WriteAllBytes($"Cache/{fileDataId}", buffer);
stream.Position = 0;
return(stream);
}
return(null);
}
/// <summary>
/// Read the WDT file.
/// </summary>
public void ReadWDT(CASCHandler handler, uint wdtfiledataid)
{
var stream = handler.OpenFile((int)wdtfiledataid);
if (stream == null)
{
return;
}
using (var reader = new BinaryReader(stream))
{
while (reader.BaseStream.Position < reader.BaseStream.Length)
{
var chunkId = (Chunk)reader.ReadUInt32();
var chunkSize = reader.ReadUInt32();
switch (chunkId)
{
case Chunk.MAID:
for (var x = 0; x < 64; ++x)
{
for (var y = 0; y < 64; ++y)
{
var rootAdt = reader.ReadUInt32();
var obj0Adt = reader.ReadUInt32();
var obj1Adt = reader.ReadUInt32();
var tex0Adt = reader.ReadUInt32();
var lodAdt = reader.ReadUInt32();
var mapTexture = reader.ReadUInt32();
var mapTextureN = reader.ReadUInt32();
var minimapTexture = reader.ReadUInt32();
if (rootAdt == 0)
{
continue;
}
MAIDs.Add($"{y}_{x}", new MAID
{
RootADT = rootAdt,
Obj0ADT = obj0Adt,
Obj1ADT = obj1Adt,
Tex0ADT = tex0Adt,
LodADT = lodAdt,
MapTexture = mapTexture,
MapTextureN = mapTextureN,
MinimapTexture = minimapTexture,
});
}
}
break;
default:
Skip(reader, chunkSize);
break;
}
}
}
}
public bool loadFile(CASCHandler cascHandler, string fileName)
{
var file = cascHandler.OpenFile(fileName);
if (file == null)
{
return(false);
}
var fileSize = file.Length;
if (fileSize == 0xFFFFFFFF)
{
return(false);
}
data_size = (uint)fileSize;
_data = new BinaryReader(file).ReadBytes((int)data_size);
parseChunks();
if (prepareLoadedData())
{
return(true);
}
Console.WriteLine($"Error loading {fileName}\n");
return(false);
}
public static Stream OpenFile(Record record, CASCHandler handler)
{
long offset = 0;
EncodingEntry enc;
if (((ContentFlags)record.record.Flags & ContentFlags.Bundle) == ContentFlags.Bundle)
{
offset = record.record.Offset;
handler.Encoding.GetEntry(record.index.bundleContentKey, out enc);
}
else
{
handler.Encoding.GetEntry(record.record.ContentKey, out enc);
}
MemoryStream ms = new MemoryStream(record.record.Size);
try {
Stream fstream = handler.OpenFile(enc.Key);
fstream.Position = offset;
CopyBytes(fstream, ms, record.record.Size);
ms.Position = 0;
} catch (Exception ex) {
Console.Out.WriteLine("Error {0} with file {2:X12}.{3:X3} ({1})", ex.Message, TypeAlias(GUID.Type(record.record.Key)), GUID.LongKey(record.record.Key), GUID.Type(record.record.Key));
return(null);
}
if (System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Log(0, "CASC:IO",
$"[CASC:IO] Opened file {GUID.LongKey(record.record.Key):X12}.{GUID.Type(record.record.Key):X3}\n");
}
return(ms);
}
private static void ParseM2_Skin(uint skinFileId, M2Data m2Data, CASCHandler CascHandler)
{
var stream = CascHandler.OpenFile(skinFileId);
using (BinaryReader reader = new BinaryReader(stream))
{
ParseSkin(reader, m2Data);
}
}
public static bool ParseWDT(uint FileDataId)
{
long streamPos = 0;
CASC = GameObject.Find("[CASC]").GetComponent <CascHandler>().cascHandler;
if (CASC.FileExists(FileDataId))
{
using (var stream = CASC.OpenFile(FileDataId))
using (var reader = new BinaryReader(stream))
{
WDTflagsdata WDTFlags = new WDTflagsdata();
while (streamPos < stream.Length)
{
stream.Position = streamPos;
WDTChunkId ChunkId = (WDTChunkId)reader.ReadUInt32();
uint ChunkSize = reader.ReadUInt32();
streamPos = stream.Position + ChunkSize;
switch (ChunkId)
{
case WDTChunkId.MVER:
ReadMVER(reader);
break;
case WDTChunkId.MPHD:
ReadMPHD(reader, WDTFlags);
break;
case WDTChunkId.MAIN:
ReadMAIN(reader, WDTFlags);
break;
case WDTChunkId.MAID:
ReadMAID(reader, FileDataId);
break;
default:
SkipUnknownChunk(stream, ChunkId, ChunkSize);
break;
}
}
if (!Flags.ContainsKey(FileDataId))
{
Flags.Add(FileDataId, WDTFlags);
}
}
return(true);
}
else
{
return(false);
}
}
public static Stream OpenFile(MD5Hash hash, CASCHandler handler)
{
try {
Stream fstream = handler.OpenFile(hash);
return(fstream);
} catch (Exception ex) {
Console.Out.WriteLine("Error {0}", ex.Message);
return(null);
}
}
// materials //
public static void ReadMOMT(BinaryReader reader, int MOMTsize, CASCHandler Handler)
{
wmoData.Info.nMaterials = MOMTsize / 64;
for (int i = 0; i < wmoData.Info.nMaterials; i++)
{
WMOMaterial material = new WMOMaterial();
material.flags = reader.ReadMaterialFlags();
material.ShaderType = (WMOFragmentShader)reader.ReadUInt32(); // Index into CMapObj::s_wmoShaderMetaData. See below (shader types).
material.BlendMode = (BlendingMode)reader.ReadUInt32(); // Blending: see https://wowdev.wiki/Rendering#EGxBlend
material.TextureId1 = reader.ReadUInt32(); // offset into MOTX; ≥ Battle (8.1.0.27826) No longer references MOTX but is a filedata id directly.
material.SidnColor = reader.ReadBGRA(); // emissive color; see below (emissive color)
material.FrameSidnColor = reader.ReadBGRA(); // sidn emissive color; set at runtime; gets sidn-manipulated emissive color; see below (emissive color)
material.TextureId2 = reader.ReadUInt32(); // Environment Texture; envNameIndex; offset into MOTX
material.DiffColor = reader.ReadBGRA(); // diffuse color; CWorldView::GatherMapObjDefGroupLiquids(): geomFactory->SetDiffuseColor((CImVectorⁱ*)(smo+7));
// environment textures don't need flags
material.GroundType = reader.ReadUInt32(); // foreign_keyⁱ< uint32_t, &TerrainTypeRec::m_ID > ground_type; // according to CMapObjDef::GetGroundType
material.TextureId3 = reader.ReadUInt32(); // offset into MOTX
material.Color = reader.ReadBGRA();
material.texture3_flags = reader.ReadMaterialFlags();
// skip runtime data //
reader.BaseStream.Seek(16, SeekOrigin.Current);
wmoData.materials.Add(material);
if (!wmoData.texturePaths.ContainsKey(material.TextureId1))
{
wmoData.texturePaths.Add(material.TextureId1, material.TextureId1);
}
if (material.TextureId1 != 0)
{
Texture2Ddata textureData = new Texture2Ddata();
Stream stream = Handler.OpenFile(material.TextureId1);
BLP blp = new BLP();
byte[] data = blp.GetUncompressed(stream, true);
BLPinfo info = blp.Info();
textureData.hasMipmaps = info.hasMipmaps;
textureData.width = info.width;
textureData.height = info.height;
textureData.textureFormat = info.textureFormat;
textureData.TextureData = data;
stream.Close();
stream.Dispose();
LoadedBLPs.Add(material.TextureId1);
if (!wmoData.textureData.ContainsKey(material.TextureId1))
{
wmoData.textureData.Add(material.TextureId1, textureData);
}
}
}
} // loaded
public static Stream OpenFile(uint fileDataId)
{
if (!cascHandler.FileExists((int)fileDataId))
{
return(null);
}
var stream = cascHandler.OpenFile((int)fileDataId);
return(stream);
}
public static Stream GetFile(string from)
{
try
{
return(CASC.OpenFile(from, LocaleFlags.All));
}
catch
{
Console.WriteLine("Problem: " + from);
return(null);
}
}
public static Stream OpenFile(CASCHandler casc, MD5Hash hash)
{
try {
return(casc.EncodingHandler.GetEntry(hash, out EncodingEntry enc) ? casc.OpenFile(enc.Key) : null);
} catch (Exception e) {
if (e is BLTEKeyException exception)
{
Debugger.Log(0, "TankLibTest:CASC", $"Missing key: {exception.MissingKey:X16}\r\n");
}
return(null);
}
}
public static IEnumerable <KeyValuePair <int, WDC3Row> > EnumerateTable(this CASCFolder folder, string name, CASCHandler handler)
{
var entry = folder.GetEntry(name + ".db2");
using var stream = handler.OpenFile(entry.Hash);
var reader = new WDC3Reader(stream);
foreach (var pair in reader)
{
yield return(pair);
}
}
// Terrain Texture Parser //
private static void ParseADT_Tex(uint TexFileDataId, CASCHandler Handler, uint WdtFileDataId)
{
ADTTex t = new ADTTex();
int MCNKchunkNumber = 0;
long StreamPos = 0;
using (var stream = Handler.OpenFile(TexFileDataId))
using (var reader = new BinaryReader(stream))
{
while (StreamPos < stream.Length)
{
stream.Position = StreamPos;
ADTChunkId chunkID = (ADTChunkId)reader.ReadInt32();
uint chunkSize = reader.ReadUInt32();
StreamPos = stream.Position + chunkSize;
switch (chunkID)
{
case ADTChunkId.MVER:
t.ReadMVER(reader); // ADT file version
break;
case ADTChunkId.MAMP:
t.ReadMAMP(reader); // Single value - texture size = 64
break;
case ADTChunkId.MCNK:
{
t.ReadMCNKtex(reader, WdtFileDataId, MCNKchunkNumber, chunkSize); // Texture Data - 256chunks
MCNKchunkNumber++;
}
break;
case ADTChunkId.MTXP:
t.ReadMTXP(reader, chunkSize);
break;
case ADTChunkId.MHID:
t.ReadMHID(reader, chunkSize, Handler);
break;
case ADTChunkId.MDID:
t.ReadMDID(reader, chunkSize, Handler);
break;
default:
SkipUnknownChunk(stream, chunkID, chunkSize);
break;
}
}
}
}
public static void CompareEnc(string[] args)
{
string otherVerNum = args[2];
HashSet <ulong> missingKeys = new HashSet <ulong>();
Directory.CreateDirectory(RawEncDir);
Directory.CreateDirectory(ConvertEncDir);
string[] otherHashes;
using (StreamReader reader = new StreamReader($"{otherVerNum}.enchashes")) {
otherHashes = reader.ReadToEnd().Split('\n').Select(x => x.TrimEnd('\r')).Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();
}
Dictionary <MD5Hash, int> otherHashDict = new Dictionary <MD5Hash, int>(new MD5HashComparer());
foreach (MD5Hash hash in otherHashes.Select(x => x.ToByteArray().ToMD5()))
{
otherHashDict[hash] = 0;
}
foreach (KeyValuePair <MD5Hash, EncodingEntry> entry in CASC.EncodingHandler.Entries)
{
string md5 = entry.Key.ToHexString();
if (!otherHashDict.ContainsKey(entry.Key))
{
try {
Stream stream = CASC.OpenFile(entry.Value.Key);
TryConvertFile(stream, ConvertEncDir, md5);
//stream.Position = 0;
//using (Stream file = File.OpenWrite(Path.Combine(RawEncDir, md5))) {
// stream.CopyTo(file);
//}
} catch (Exception e) {
if (e is BLTEKeyException exception)
{
if (missingKeys.Add(exception.MissingKey))
{
Console.Out.WriteLine($"Missing key: {exception.MissingKey:X16}");
}
}
else
{
Console.Out.WriteLine(e);
}
}
}
}
}
protected Stream OpenFile(string filePath)
{
if (StorageMode == StorageMode.CASC)
{
return(CASCHandler.OpenFile(filePath));
}
else if (StorageMode == StorageMode.Mods)
{
return(File.Open(Path.Combine(ModsFolderPath, filePath.Substring(5)), FileMode.Open));
}
else
{
return(null);
}
}
// Terrain Mesh Parser //
private static void ParseADT_Main(uint RootAdtFileDataId, CASCHandler Handler) // MS version
{
ADTRoot r = new ADTRoot();
int MCNKchunkNumber = 0;
long StreamPos = 0;
using (var stream = Handler.OpenFile(RootAdtFileDataId))
using (var reader = new BinaryReader(stream))
{
while (StreamPos < stream.Length)
{
stream.Position = StreamPos;
ADTChunkId chunkID = (ADTChunkId)reader.ReadInt32();
uint chunkSize = reader.ReadUInt32();
StreamPos = stream.Position + chunkSize;
switch (chunkID)
{
case ADTChunkId.MVER:
r.ReadMVER(reader); // ADT file version
break;
case ADTChunkId.MHDR:
r.ReadMHDR(reader); // Offsets for specific chunks 0000 if chunks don't exist.
break;
// case ADTChunkId.MH2O:
// r.ReadMH2O(reader, chunkSize); // Water Data
// break;
case ADTChunkId.MCNK:
{
r.ReadMCNK(reader, MCNKchunkNumber, chunkSize); // Terrain Data - 256chunks
MCNKchunkNumber++;
}
break;
case ADTChunkId.MFBO:
r.ReadMFBO(reader); // FlightBounds plane & Death plane
break;
default:
SkipUnknownChunk(stream, chunkID, chunkSize);
break;
}
}
}
}
/// <summary>
/// Open a new <see cref="BinaryReader"/> instance with the given FileId.
/// </summary>
public static BinaryReader OpenFile(uint fileDataId)
{
if (!NewStorage.FileExists((int)fileDataId))
{
return(null);
}
var stream = NewStorage.OpenFile((int)fileDataId);
if (stream == null)
{
return(null);
}
return(new BinaryReader(stream));
}
// Terrain Models Parser //
public static void ParseADT_Obj(uint OBJFileDataId, CASCHandler Handler)
{
ADTObj o = new ADTObj();
int MCNKchunkNumber = 0;
long StreamPos = 0;
using (var stream = Handler.OpenFile(OBJFileDataId))
using (BinaryReader reader = new BinaryReader(stream))
{
while (stream.Position < stream.Length)
{
stream.Position = StreamPos;
ADTChunkId chunkID = (ADTChunkId)reader.ReadInt32();
uint chunkSize = reader.ReadUInt32();
StreamPos = stream.Position + chunkSize;
switch (chunkID)
{
case ADTChunkId.MVER:
o.ReadMVER(reader); // ADT file version
break;
case ADTChunkId.MDDF:
o.ReadMDDF(reader, chunkSize); // Placement information for doodads (M2 models).
break;
case ADTChunkId.MODF:
o.ReadMODF(reader, chunkSize); // Placement information for WMOs.
break;
case ADTChunkId.MCNK:
{
o.ReadMCNKObj(reader, MCNKchunkNumber, chunkSize); // 256chunks
MCNKchunkNumber++;
}
break;
default:
SkipUnknownChunk(stream, chunkID, chunkSize);
break;
}
}
}
}
public DB2Reader(uint FileDataId)
{
Casc = GameObject.Find("[CASC]").GetComponent <CascHandler>().cascHandler;
var stream = Casc.OpenFile(FileDataId);
using (var bin = new BinaryReader(stream))
{
var identifier = new string(bin.ReadChars(4));
stream.Position = 0;
switch (identifier)
{
case "WDC3":
_reader = new WDC3(stream);
break;
default:
Debug.Log("DBC Type " + identifier + " is not supported");
break;
}
}
}
public static Stream OpenFile(PackageRecord record, CASCHandler handler)
{
long offset = 0;
EncodingEntry enc;
if (record.Flags.HasFlag(ContentFlags.Bundle))
{
offset = record.Offset;
}
if (!handler.Encoding.GetEntry(record.Hash, out enc))
{
return(null);
}
MemoryStream ms = new MemoryStream((int)record.Size);
try
{
Stream fstream = handler.OpenFile(enc.Key);
fstream.Position = offset;
CopyBytes(fstream, ms, (int)record.Size);
ms.Position = 0;
}
catch (Exception ex)
{
Console.Out.WriteLine("Error {0} with file {2} ({1})", ex.Message, TypeAlias(GUID.Type(record.GUID)), GUID.AsString(record.GUID));
return(null);
}
if (System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Log(0, "CASC:IO",
$"[CASC:IO] Opened file {GUID.AsString(record.GUID)}\n");
}
return(ms);
}
private static void ParseM2_Root(uint fileDataID, M2Data m2Data, M2Texture m2Tex, CASCHandler CascHandler)
{
long streamPos = 0;
using (var stream = CascHandler.OpenFile(fileDataID))
using (BinaryReader reader = new BinaryReader(stream))
{
while (streamPos < stream.Length)
{
stream.Position = streamPos;
M2ChunkId chunkID = (M2ChunkId)reader.ReadUInt32();
uint chunkSize = reader.ReadUInt32();
streamPos = stream.Position + chunkSize;
switch (chunkID)
{
case M2ChunkId.MD21:
ReadMD21(reader, m2Data, m2Tex);
break;
case M2ChunkId.SFID:
ReadSFID(reader, chunkSize);
break;
case M2ChunkId.TXID:
ReadTXID(reader, m2Data, CascHandler, chunkSize);
break;
default:
SkipUnknownChunk(stream, chunkSize);
break;
}
}
};
}
protected override void LoadCoreStormMod()
{
SetCorrectFileCasing();
if (LoadXmlFilesEnabled)
{
// core.stormmod xml files
CASCFolder currentFolder = CASCFolderData.GetDirectory(Path.Combine(CoreBaseDataDirectoryPath, GameDataStringName));
foreach (KeyValuePair <string, ICASCEntry> file in currentFolder.Entries)
{
if (Path.GetExtension(file.Key) != ".xml")
{
continue;
}
string filePath = ((CASCFile)file.Value).FullName;
if (!CASCHandlerData.FileExists(filePath))
{
throw new FileNotFoundException(filePath);
}
using (Stream stream = CASCHandlerData.OpenFile(filePath))
{
if (XmlGameData.LastNode == null)
{
XmlGameData = XDocument.Load(stream);
XmlFileCount++;
if (IsCacheEnabled)
{
AddXmlCachedFilePath(filePath);
}
}
else
{
LoadXmlFile(stream, filePath);
}
}
}
}
if (LoadTextFilesOnlyEnabled)
{
string filePath = Path.Combine(CoreLocalizedDataPath, GameStringFile);
LoadTextFile(CASCHandlerData.OpenFile(filePath), filePath);
}
string fontStylesFilePath = Path.Combine(CoreBaseDataDirectoryPath, UIDirectoryStringName, FontStyleFile);
LoadStormStyleFile(CASCHandlerData.OpenFile(fontStylesFilePath));
if (IsCacheEnabled)
{
AddStormStyleCachedFilePath(fontStylesFilePath);
}
}
public static Stream ReadThisFile(string filename)
{
Stream stream = null;
if (usingCasc) //CASC
{
stream = cascHandler.OpenFile(filename);
}
else //MPQ
{
//Find the goddamn file in the archive hell
int index = MainListFile.FindIndex(a => a.Contains(filename.ToLower()));
if (index != -1)
{
//Get the archive in which the requested file resides
string archive = MainListFile[index];
archive = archive.Substring(archive.LastIndexOf(';', archive.Length - 2) + 1);
switch (archive.Substring(0, archive.Length - 4).Replace("-", ""))
{
//Mysts
case "expansion4":
stream = expansion4.OpenFile(filename);
break;
case "model":
stream = model.OpenFile(filename);
break;
//Cataclysm
case "art":
stream = art.OpenFile(filename);
break;
case "expansion1":
stream = expansion1.OpenFile(filename);
break;
case "expansion2":
stream = expansion2.OpenFile(filename);
break;
case "expansion3":
stream = expansion3.OpenFile(filename);
break;
case "world":
stream = world.OpenFile(filename);
break;
case "world2":
stream = world2.OpenFile(filename);
break;
case "locale1":
stream = locale1.OpenFile(filename);
break;
//Lich King
case "common":
stream = common.OpenFile(filename);
break;
case "common2":
stream = common2.OpenFile(filename);
break;
case "expansion":
stream = expansion.OpenFile(filename);
break;
case "lichking":
stream = lichking.OpenFile(filename);
break;
case "patch":
stream = patch.OpenFile(filename);
break;
case "patch2":
stream = patch2.OpenFile(filename);
break;
case "patch3":
stream = patch3.OpenFile(filename);
break;
//Vanilla
case "base":
stream = baseMPQ.OpenFile(filename);
break;
case "dbc":
stream = dbc.OpenFile(filename);
break;
case "interface":
stream = interfaceMPQ.OpenFile(filename);
break;
case "misc":
stream = misc.OpenFile(filename);
break;
case "sound":
stream = sound.OpenFile(filename);
break;
case "terrain":
stream = terrain.OpenFile(filename);
break;
case "texture":
stream = texture.OpenFile(filename);
break;
case "wmo":
stream = wmo.OpenFile(filename);
break;
}
}
else
{
//Missing file
stream = null;
}
}
return(stream);
}
public static Stream OpenFile(string filename)
{
return(cascHandler.OpenFile(filename));
}
