mirror of
https://github.com/OpenDiablo2/OpenDiablo2
synced 2024-09-30 15:15:56 -04:00
358 lines
12 KiB
C#
358 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using OpenDiablo2.Common.Interfaces;
|
|
|
|
namespace OpenDiablo2.Common.Models
|
|
{
|
|
|
|
public sealed class MPQDS1TileProps
|
|
{
|
|
public byte Prop1 { get; internal set; }
|
|
public byte Prop2 { get; internal set; }
|
|
public byte Prop3 { get; internal set; }
|
|
public byte Prop4 { get; internal set; }
|
|
}
|
|
|
|
public sealed class MPQDS1WallOrientationTileProps
|
|
{
|
|
public byte Orientation1 { get; internal set; }
|
|
public byte Orientation2 { get; internal set; }
|
|
public byte Orientation3 { get; internal set; }
|
|
public byte Orientation4 { get; internal set; }
|
|
}
|
|
|
|
public sealed class MPQDS1WallLayer
|
|
{
|
|
public MPQDS1TileProps[] Props { get; internal set; }
|
|
public MPQDS1WallOrientationTileProps[] Orientations { get; internal set; }
|
|
}
|
|
|
|
public sealed class MPQDS1FloorLayer
|
|
{
|
|
public MPQDS1TileProps[] Props { get; internal set; }
|
|
}
|
|
|
|
public sealed class MPQDS1ShadowLayer
|
|
{
|
|
public MPQDS1TileProps[] Props { get; internal set; }
|
|
}
|
|
|
|
public sealed class MPQDS1Object
|
|
{
|
|
public Int32 Type { get; internal set; }
|
|
public Int32 Id { get; internal set; }
|
|
public Int32 X { get; internal set; }
|
|
public Int32 Y { get; internal set; }
|
|
public Int32 DS1Flags { get; internal set; }
|
|
}
|
|
|
|
public sealed class MPQDS1Group
|
|
{
|
|
public Int32 TileX { get; internal set; }
|
|
public Int32 TileY { get; internal set; }
|
|
public Int32 Width { get; internal set; }
|
|
public Int32 Height { get; internal set; }
|
|
}
|
|
|
|
public sealed class MPQDS1
|
|
{
|
|
static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
public Int32 Version { get; internal set; }
|
|
public Int32 Width { get; internal set; }
|
|
public Int32 Height { get; internal set; }
|
|
public Int32 Act { get; internal set; } // ???
|
|
public Int32 TagType { get; internal set; } // ???
|
|
public Int32 FileCount { get; internal set; }
|
|
public Int32 NumberOfWalls { get; internal set; }
|
|
public Int32 NumberOfFloors { get; internal set; }
|
|
public Int32 NumberOfObjects { get; internal set; }
|
|
public Int32 NumberOfNPCs { get; internal set; }
|
|
public Int32 NumberOfTags { get; internal set; }
|
|
public Int32 NumberOfGroups { get; internal set; }
|
|
|
|
public MPQDT1[] DT1s = new MPQDT1[33];
|
|
|
|
public List<string> FileNames { get; internal set; } = new List<string>();
|
|
public MPQDS1WallLayer[] WallLayers { get; internal set; }
|
|
public MPQDS1FloorLayer[] FloorLayers { get; internal set; }
|
|
public MPQDS1ShadowLayer[] ShadowLayers { get; internal set; }
|
|
public MPQDS1Object[] Objects { get; internal set; }
|
|
public MPQDS1Group[] Groups { get; internal set; }
|
|
|
|
// TODO: DI magic please
|
|
public MPQDS1(Stream stream, string fileName, int definition, int act, IEngineDataManager engineDataManager, IResourceManager resourceManager)
|
|
{
|
|
log.Debug($"Loading {fileName} (Act {act}) Def {definition}");
|
|
var br = new BinaryReader(stream);
|
|
Version = br.ReadInt32();
|
|
Width = br.ReadInt32() + 1;
|
|
Height = br.ReadInt32() + 1;
|
|
Act = br.ReadInt32() + 1;
|
|
|
|
if (Version >= 10)
|
|
{
|
|
TagType = br.ReadInt32();
|
|
if (TagType == 1 || TagType == 2)
|
|
NumberOfTags = 1;
|
|
}
|
|
|
|
FileCount = 0;
|
|
if (Version >= 3)
|
|
{
|
|
FileCount = br.ReadInt32();
|
|
for (int i = 0; i < FileCount; i++)
|
|
{
|
|
var fn = "";
|
|
while (true)
|
|
{
|
|
var b = br.ReadByte();
|
|
if (b == 0)
|
|
break;
|
|
fn += (char)b;
|
|
}
|
|
if (fn.StartsWith("\\d2\\"))
|
|
fn = fn.Substring(4);
|
|
FileNames.Add(fn);
|
|
}
|
|
}
|
|
|
|
if (Version >= 9 && Version <= 13)
|
|
{
|
|
br.ReadBytes(8);
|
|
}
|
|
|
|
if (Version >= 4)
|
|
{
|
|
NumberOfWalls = br.ReadInt32();
|
|
|
|
if (Version >= 16)
|
|
{
|
|
NumberOfFloors = br.ReadInt32();
|
|
}
|
|
else NumberOfFloors = 1;
|
|
}
|
|
else
|
|
{
|
|
NumberOfFloors = 1;
|
|
NumberOfWalls = 1;
|
|
NumberOfTags = 1;
|
|
}
|
|
|
|
|
|
|
|
var layoutStream = new List<int>();
|
|
|
|
if (Version < 4)
|
|
{
|
|
layoutStream.AddRange(new int[] { 1, 9, 5, 12, 11 });
|
|
}
|
|
else
|
|
{
|
|
for (var x = 0; x < NumberOfWalls; x++)
|
|
{
|
|
layoutStream.Add(1 + x);
|
|
layoutStream.Add(5 + x);
|
|
}
|
|
for (var x = 0; x < NumberOfFloors; x++)
|
|
layoutStream.Add(9 + x);
|
|
|
|
layoutStream.Add(11);
|
|
|
|
if (NumberOfTags > 0)
|
|
layoutStream.Add(12);
|
|
}
|
|
|
|
WallLayers = new MPQDS1WallLayer[NumberOfWalls];
|
|
for (var l = 0; l < NumberOfWalls; l++)
|
|
{
|
|
WallLayers[l] = new MPQDS1WallLayer
|
|
{
|
|
Orientations = new MPQDS1WallOrientationTileProps[Width * Height],
|
|
Props = new MPQDS1TileProps[Width * Height]
|
|
};
|
|
}
|
|
|
|
FloorLayers = new MPQDS1FloorLayer[NumberOfFloors];
|
|
for (var l = 0; l < NumberOfFloors; l++)
|
|
{
|
|
FloorLayers[l] = new MPQDS1FloorLayer
|
|
{
|
|
Props = new MPQDS1TileProps[Width * Height]
|
|
};
|
|
}
|
|
|
|
ShadowLayers = new MPQDS1ShadowLayer[1];
|
|
for (var l = 0; l < 1; l++)
|
|
{
|
|
ShadowLayers[l] = new MPQDS1ShadowLayer
|
|
{
|
|
Props = new MPQDS1TileProps[Width * Height]
|
|
};
|
|
}
|
|
|
|
|
|
for (int n = 0; n < layoutStream.Count(); n++)
|
|
{
|
|
for (var y = 0; y < Height; y++)
|
|
{
|
|
for (var x = 0; x < Width; x++)
|
|
{
|
|
switch (layoutStream[n])
|
|
{
|
|
// Walls
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
WallLayers[layoutStream[n] - 1].Props[x + (y * Width)] = new MPQDS1TileProps
|
|
{
|
|
Prop1 = br.ReadByte(),
|
|
Prop2 = br.ReadByte(),
|
|
Prop3 = br.ReadByte(),
|
|
Prop4 = br.ReadByte()
|
|
};
|
|
break;
|
|
|
|
// Orientations
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
// TODO: Orientations
|
|
if (Version < 7)
|
|
{
|
|
br.ReadBytes(4);
|
|
}
|
|
else
|
|
{
|
|
br.ReadBytes(4);
|
|
}
|
|
break;
|
|
|
|
// Floors
|
|
case 9:
|
|
case 10:
|
|
FloorLayers[layoutStream[n] - 9].Props[x + (y * Width)] = new MPQDS1TileProps
|
|
{
|
|
Prop1 = br.ReadByte(),
|
|
Prop2 = br.ReadByte(),
|
|
Prop3 = br.ReadByte(),
|
|
Prop4 = br.ReadByte()
|
|
};
|
|
break;
|
|
// Shadow
|
|
case 11:
|
|
ShadowLayers[layoutStream[n] - 11].Props[x + (y * Width)] = new MPQDS1TileProps
|
|
{
|
|
Prop1 = br.ReadByte(),
|
|
Prop2 = br.ReadByte(),
|
|
Prop3 = br.ReadByte(),
|
|
Prop4 = br.ReadByte()
|
|
};
|
|
break;
|
|
// Tags
|
|
case 12:
|
|
// TODO: Tags
|
|
br.ReadBytes(4);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
NumberOfObjects = 0;
|
|
if (Version >= 2)
|
|
{
|
|
|
|
NumberOfObjects = br.ReadInt32();
|
|
Objects = new MPQDS1Object[NumberOfObjects];
|
|
|
|
for (int i = 0; i < NumberOfObjects; i++)
|
|
{
|
|
Objects[i] = new MPQDS1Object
|
|
{
|
|
Type = br.ReadInt32(),
|
|
Id = br.ReadInt32(),
|
|
X = br.ReadInt32(),
|
|
Y = br.ReadInt32()
|
|
};
|
|
|
|
if (Version > 5)
|
|
Objects[i].DS1Flags = br.ReadInt32();
|
|
|
|
}
|
|
}
|
|
|
|
|
|
if (Version >= 12 && TagType == 1 || TagType == 2)
|
|
{
|
|
if (Version >= 18)
|
|
br.ReadBytes(4);
|
|
|
|
NumberOfGroups = br.ReadInt32();
|
|
}
|
|
else NumberOfGroups = 0;
|
|
|
|
|
|
Groups = new MPQDS1Group[NumberOfGroups];
|
|
for (var x = 0; x < NumberOfGroups; x++)
|
|
{
|
|
Groups[x] = new MPQDS1Group
|
|
{
|
|
TileX = br.ReadInt32(),
|
|
TileY = br.ReadInt32(),
|
|
Width = br.ReadInt32(),
|
|
Height = br.ReadInt32(),
|
|
};
|
|
if (Version >= 13)
|
|
br.ReadBytes(4);
|
|
}
|
|
|
|
if (Version >= 14)
|
|
{
|
|
|
|
NumberOfNPCs = br.ReadInt32();
|
|
}*/
|
|
|
|
|
|
LevelPreset levelPreset;
|
|
if (definition == -1)
|
|
{
|
|
levelPreset = engineDataManager.LevelPresets.First(x =>
|
|
x.File1.ToLower() == fileName.ToLower()
|
|
|| x.File2.ToLower() == fileName.ToLower()
|
|
|| x.File3.ToLower() == fileName.ToLower()
|
|
|| x.File4.ToLower() == fileName.ToLower()
|
|
|| x.File5.ToLower() == fileName.ToLower()
|
|
|| x.File6.ToLower() == fileName.ToLower());
|
|
}
|
|
else
|
|
{
|
|
levelPreset = engineDataManager.LevelPresets.First(x => x.Def == definition);
|
|
}
|
|
|
|
var dt1Mask = levelPreset.Dt1Mask;
|
|
var levelType = engineDataManager.LevelTypes.First(x => x.Id == levelPreset.LevelId && x.Act == act);
|
|
|
|
|
|
for (int i = 0; i < 32; i++)
|
|
{
|
|
var tilePath = levelType.File[i];
|
|
var isMasked = ((dt1Mask >> i) & 1) == 1;
|
|
if (!isMasked)
|
|
continue;
|
|
|
|
log.Debug($"Loading DT resource {levelType.File[i]}");
|
|
|
|
DT1s[i] = resourceManager.GetMPQDT1("data\\global\\tiles\\" + levelType.File[i].Replace("/", "\\"));
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|