public TexInfo(byte[] data, mapType type):base(data) {
axes = new Vector3D[2];
axes[S] = DataReader.readPoint3F(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]);
shifts[S] = DataReader.readFloat(data[12], data[13], data[14], data[15]);
axes[T] = DataReader.readPoint3F(data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23], data[24], data[25], data[26], data[27]);
shifts[T] = DataReader.readFloat(data[28], data[29], data[30], data[31]);
switch (type) {
// Excluded engines: Quake 2-based, Quake 3-based
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
texture = DataReader.readInt(data[68], data[69], data[70], data[71]);
flags = DataReader.readInt(data[64], data[65], data[66], data[67]);
break;
case mapType.TYPE_DMOMAM:
texture = DataReader.readInt(data[92], data[93], data[94], data[95]);
flags = DataReader.readInt(data[88], data[89], data[90], data[91]);
break;
case mapType.TYPE_QUAKE:
texture = DataReader.readInt(data[32], data[33], data[34], data[35]);
flags = DataReader.readInt(data[36], data[37], data[38], data[39]);
break;
case mapType.TYPE_NIGHTFIRE:
break;
}
}
public static Map GetMap(mapType mapType)
{
var map = new Map();
using (IDbConnection dbcon = new SqliteConnection(connection))
{
dbcon.Open();
IDbCommand dbcmd;
IDataReader reader;
dbcmd = dbcon.CreateCommand();
dbcmd.CommandText = "SELECT * FROM MAPS WHERE name='" + mapType + "'";
reader = dbcmd.ExecuteReader();
while (reader.Read())
{
map.Name = reader["name"].ToString();
map.Description = reader["description"].ToString();
map.Id = int.Parse(reader["id"].ToString());
map.X = int.Parse(reader["X"].ToString());
map.Y = int.Parse(reader["Y"].ToString());
}
}
map.Rows.AddRange(GetRows(map));
return(map);
}
// METHODS
public static Lump<SourceCubemap> createLump(byte[] data, mapType type) {
int structLength = 0;
switch (type) {
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
structLength = 16;
break;
default:
structLength = 0; // This will cause the shit to hit the fan.
break;
}
int offset = 0;
Lump<SourceCubemap> lump = new Lump<SourceCubemap>(data.Length, structLength, data.Length / structLength);
byte[] bytes = new byte[structLength];
for (int i = 0; i < data.Length / structLength; i++) {
for (int j = 0; j < structLength; j++) {
bytes[j] = data[offset + j];
}
lump.Add(new SourceCubemap(bytes, type));
offset += structLength;
}
return lump;
}
public DThing(byte[] data, mapType type) : base(data)
{
switch (type)
{
case mapType.TYPE_DOOM:
origin = new Vector3D(DataReader.readShort(data[0], data[1]), DataReader.readShort(data[2], data[3]));
this.angle = DataReader.readShort(data[4], data[5]);
this.classNum = DataReader.readShort(data[6], data[7]);
this.flags = DataReader.readShort(data[8], data[9]);
break;
case mapType.TYPE_HEXEN:
id = DataReader.readShort(data[0], data[1]);
origin = new Vector3D(DataReader.readShort(data[2], data[3]), DataReader.readShort(data[4], data[5]), DataReader.readShort(data[6], data[7]));
this.angle = DataReader.readShort(data[8], data[9]);
this.classNum = DataReader.readShort(data[10], data[11]);
this.flags = DataReader.readShort(data[12], data[13]);
action = data[14];
arguments[0] = data[15];
arguments[1] = data[16];
arguments[2] = data[17];
arguments[3] = data[18];
arguments[4] = data[19];
break;
}
}
// METHODS
//UPGRADE_ISSUE: The following fragment of code could not be parsed and was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextSettingsIndex'&keyword='jlca1156'"
public static Lump <DThing> createLump(byte[] data, mapType type)
{
int structLength = 0;
switch (type)
{
case mapType.TYPE_DOOM:
structLength = 10;
break;
case mapType.TYPE_HEXEN:
structLength = 20;
break;
}
int offset = 0;
Lump <DThing> lump = new Lump <DThing>(data.Length, structLength, data.Length / structLength);
byte[] bytes = new byte[structLength];
for (int i = 0; i < data.Length / structLength; i++)
{
for (int j = 0; j < structLength; j++)
{
bytes[j] = data[offset + j];
}
lump.Add(new DThing(bytes, type));
offset += structLength;
}
return(lump);
}
// This constructor takes bytes in a byte array, as though
// it had just been read by a FileInputStream.
public Edge(byte[] data, mapType type):base(data) {
switch (type) {
case mapType.TYPE_QUAKE:
case mapType.TYPE_SIN:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_DMOMAM:
case mapType.TYPE_QUAKE2:
case mapType.TYPE_SOF:
firstVertex = DataReader.readUShort(data[0], data[1]);
secondVertex = DataReader.readUShort(data[2], data[3]);
break;
case mapType.TYPE_VINDICTUS:
firstVertex = DataReader.readInt(data[0], data[1], data[2], data[3]);
secondVertex = DataReader.readInt(data[4], data[5], data[6], data[7]);
break;
case mapType.TYPE_DOOM:
case mapType.TYPE_HEXEN:
firstVertex = DataReader.readUShort(data[0], data[1]);
secondVertex = DataReader.readUShort(data[2], data[3]);
break;
}
}
public DLinedef(byte[] data, mapType type) : base(data)
{
start = DataReader.readShort(data[0], data[1]);
end = DataReader.readShort(data[2], data[3]);
flags = new byte[] { data[4], data[5] };
switch (type)
{
case mapType.TYPE_DOOM:
action = DataReader.readShort(data[6], data[7]);
tag = DataReader.readShort(data[8], data[9]);
right = DataReader.readShort(data[10], data[11]);
left = DataReader.readShort(data[12], data[13]);
break;
case mapType.TYPE_HEXEN:
action = data[6];
arguments[0] = data[7];
arguments[1] = data[8];
arguments[2] = data[9];
arguments[3] = data[10];
arguments[4] = data[11];
right = DataReader.readShort(data[12], data[13]);
left = DataReader.readShort(data[14], data[15]);
break;
}
}
// This constructor takes bytes in a byte array, as though
// it had just been read by a FileInputStream.
public Edge(byte[] data, mapType type) : base(data)
{
switch (type)
{
case mapType.TYPE_QUAKE:
case mapType.TYPE_SIN:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_DMOMAM:
case mapType.TYPE_QUAKE2:
case mapType.TYPE_SOF:
firstVertex = DataReader.readUShort(data[0], data[1]);
secondVertex = DataReader.readUShort(data[2], data[3]);
break;
case mapType.TYPE_VINDICTUS:
firstVertex = DataReader.readInt(data[0], data[1], data[2], data[3]);
secondVertex = DataReader.readInt(data[4], data[5], data[6], data[7]);
break;
case mapType.TYPE_DOOM:
case mapType.TYPE_HEXEN:
firstVertex = DataReader.readUShort(data[0], data[1]);
secondVertex = DataReader.readUShort(data[2], data[3]);
break;
}
}
public MapInfo generateRandomMap(
mapTheme theme,
mapType mType,
int width, int height,
[Optional] NativeString64 seed,
[Optional] float squareSize)
{
seed = (seed.LengthInBytes == 0) ? Time.realtimeSinceStartup.ToString() : seed;
squareSize = (squareSize == 0) ? DEFAULT_SQUARE_SIZE : squareSize;
Entity map = mapGenWorld.EntityManager.CreateEntity();
mapGenWorld.EntityManager.AddComponentData(map, new MapGenRequirement {
width = width,
height = height,
mType = mType,
randomFillPercent = 45,
seed = seed,
squareSize = squareSize
});
var mapInfo = new MapInfo {
entity = map, theme = theme, seed = seed, genStage = generationStage.tileGen
};
mapGenWorld.EntityManager.AddComponentData(map, new TileMapGeneration.T_InitialGen {
});
mapGenWorld.EntityManager.AddComponentData(map, new MapInfo {
entity = map, theme = theme, seed = seed, genStage = generationStage.tileGen
});
return(mapInfo);
}
public DecompilerThread(FileInfo BSPFile, int jobnum, mapType openAs)
{
// Set up global variables
this.BSPFile = BSPFile;
this.jobnum = jobnum;
this.openAs = openAs;
}
// This constructor takes bytes in a byte array, as though
// it had just been read by a FileInputStream.
public SourceDispInfo(byte[] data, mapType type):base(data) {
startPosition = DataReader.readPoint3F(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]);
dispVertStart = DataReader.readInt(data[12], data[13], data[14], data[15]);
//dispTriStart=DataReader.readInt(in[16], in[17], in[18], in[19]);
power = DataReader.readInt(data[20], data[21], data[22], data[23]);
allowedVerts = new uint[10];
int offset = 0;
switch (type) {
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_DMOMAM:
offset = 136;
break;
case mapType.TYPE_SOURCE22:
offset = 140;
break;
case mapType.TYPE_SOURCE23:
offset = 144;
break;
case mapType.TYPE_VINDICTUS:
offset = 192;
break;
}
for (int i = 0; i < 10; i++) {
allowedVerts[i] = DataReader.readUInt(data[offset + (i * 4)], data[offset + 1 + (i * 4)], data[offset + 2 + (i * 4)], data[offset + 3 + (i * 4)]);
}
}
public Leaf(byte[] data, mapType type) : base(data)
{
switch (type)
{
case mapType.TYPE_SOF:
contents = new byte[] { data[0], data[1], data[2], data[3] };
firstMarkFace = DataReader.readUShort(data[22], data[23]);
numMarkFaces = DataReader.readUShort(data[24], data[25]);
firstMarkBrush = DataReader.readUShort(data[26], data[27]);
numMarkBrushes = DataReader.readUShort(data[28], data[29]);
break;
case mapType.TYPE_QUAKE2:
case mapType.TYPE_SIN:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_DMOMAM:
case mapType.TYPE_DAIKATANA:
contents = new byte[] { data[0], data[1], data[2], data[3] };
firstMarkBrush = DataReader.readUShort(data[24], data[25]);
numMarkBrushes = DataReader.readUShort(data[26], data[27]);
goto case mapType.TYPE_QUAKE;
case mapType.TYPE_QUAKE:
firstMarkFace = DataReader.readUShort(data[20], data[21]);
numMarkFaces = DataReader.readUShort(data[22], data[23]);
break;
case mapType.TYPE_VINDICTUS:
contents = new byte[] { data[0], data[1], data[2], data[3] };
firstMarkBrush = DataReader.readInt(data[44], data[45], data[46], data[47]);
numMarkBrushes = DataReader.readInt(data[48], data[49], data[50], data[51]);
break;
case mapType.TYPE_NIGHTFIRE:
contents = new byte[] { data[0], data[1], data[2], data[3] };
goto case mapType.TYPE_RAVEN;
case mapType.TYPE_QUAKE3:
case mapType.TYPE_FAKK:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_STEF2:
case mapType.TYPE_MOHAA:
case mapType.TYPE_RAVEN:
firstMarkFace = DataReader.readInt(data[32], data[33], data[34], data[35]);
numMarkFaces = DataReader.readInt(data[36], data[37], data[38], data[39]);
firstMarkBrush = DataReader.readInt(data[40], data[41], data[42], data[43]);
numMarkBrushes = DataReader.readInt(data[44], data[45], data[46], data[47]);
break;
}
}
public Texture(byte[] data, mapType type) : base(data)
{
switch (type)
{
case mapType.TYPE_NIGHTFIRE:
name = DataReader.readNullTerminatedString(new byte[] { data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11], data[12], data[13], data[14], data[15], data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23], data[24], data[25], data[26], data[27], data[28], data[29], data[30], data[31], data[32], data[33], data[34], data[35], data[36], data[37], data[38], data[39], data[40], data[41], data[42], data[43], data[44], data[45], data[46], data[47], data[48], data[49], data[50], data[51], data[52], data[53], data[54], data[55], data[56], data[57], data[58], data[59], data[60], data[61], data[62], data[63] });
break;
case mapType.TYPE_QUAKE:
name = DataReader.readNullTerminatedString(new byte[] { data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11], data[12], data[13], data[14], data[15] });
break;
case mapType.TYPE_QUAKE2:
case mapType.TYPE_SOF:
case mapType.TYPE_DAIKATANA:
texAxes = new TexInfo(DataReader.readPoint3F(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]), DataReader.readFloat(data[12], data[13], data[14], data[15]), DataReader.readPoint3F(data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23], data[24], data[25], data[26], data[27]), DataReader.readFloat(data[28], data[29], data[30], data[31]), -1, -1);
flags = new byte[] { data[32], data[33], data[34], data[35] };
name = DataReader.readNullTerminatedString(new byte[] { data[40], data[41], data[42], data[43], data[44], data[45], data[46], data[47], data[48], data[49], data[50], data[51], data[52], data[53], data[54], data[55], data[56], data[57], data[58], data[59], data[60], data[61], data[62], data[63], data[64], data[65], data[66], data[67], data[68], data[69], data[70], data[71] });
break;
case mapType.TYPE_MOHAA:
mask = DataReader.readNullTerminatedString(new byte[] { data[76], data[77], data[78], data[79], data[80], data[81], data[82], data[83], data[84], data[85], data[86], data[87], data[88], data[89], data[90], data[91], data[92], data[93], data[94], data[95], data[96], data[97], data[98], data[99], data[100], data[101], data[102], data[103], data[104], data[105], data[106], data[107], data[108], data[109], data[110], data[111], data[112], data[113], data[114], data[115], data[116], data[117], data[118], data[119], data[120], data[121], data[122], data[123], data[124], data[125], data[126], data[127], data[128], data[129], data[130], data[131], data[132], data[133], data[134], data[135], data[136], data[137], data[138], data[139] });
goto case mapType.TYPE_STEF2;
case mapType.TYPE_STEF2:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_RAVEN:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_COD:
case mapType.TYPE_COD2:
case mapType.TYPE_COD4:
case mapType.TYPE_FAKK:
name = DataReader.readNullTerminatedString(new byte[] { data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11], data[12], data[13], data[14], data[15], data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23], data[24], data[25], data[26], data[27], data[28], data[29], data[30], data[31], data[32], data[33], data[34], data[35], data[36], data[37], data[38], data[39], data[40], data[41], data[42], data[43], data[44], data[45], data[46], data[47], data[48], data[49], data[50], data[51], data[52], data[53], data[54], data[55], data[56], data[57], data[58], data[59], data[60], data[61], data[62], data[63] });
flags = new byte[] { data[64], data[65], data[66], data[67] };
contents = new byte[] { data[68], data[69], data[70], data[71] };
break;
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
name = DataReader.readString(data);
break;
case mapType.TYPE_SIN:
texAxes = new TexInfo(DataReader.readPoint3F(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]), DataReader.readFloat(data[12], data[13], data[14], data[15]), DataReader.readPoint3F(data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23], data[24], data[25], data[26], data[27]), DataReader.readFloat(data[28], data[29], data[30], data[31]), -1, -1);
flags = new byte[] { data[32], data[33], data[34], data[35] };
name = DataReader.readNullTerminatedString(new byte[] { data[36], data[37], data[38], data[39], data[40], data[41], data[42], data[43], data[44], data[45], data[46], data[47], data[48], data[49], data[50], data[51], data[52], data[53], data[54], data[55], data[56], data[57], data[58], data[59], data[60], data[61], data[62], data[63], data[64], data[65], data[66], data[67], data[68], data[69], data[70], data[71], data[72], data[73], data[74], data[75], data[76], data[77], data[78], data[79], data[80], data[81], data[82], data[83], data[84], data[85], data[86], data[87], data[88], data[89], data[90], data[91], data[92], data[93], data[94], data[95], data[96], data[97], data[98], data[99] });
break;
}
}
public BrushSide(byte[] data, mapType type):base(data) {
switch (type) {
case mapType.TYPE_COD:
// Call of Duty's format sucks. The first field is either a float or an int
// depending on whether or not it's one of the first six sides in a brush.
case mapType.TYPE_COD2:
case mapType.TYPE_COD4:
dist = DataReader.readFloat(data[0], data[1], data[2], data[3]);
goto case mapType.TYPE_QUAKE3;
case mapType.TYPE_QUAKE3:
case mapType.TYPE_FAKK:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_MOHAA:
plane = DataReader.readInt(data[0], data[1], data[2], data[3]);
texture = DataReader.readInt(data[4], data[5], data[6], data[7]);
break;
case mapType.TYPE_STEF2:
texture = DataReader.readInt(data[0], data[1], data[2], data[3]);
plane = DataReader.readInt(data[4], data[5], data[6], data[7]);
break;
case mapType.TYPE_RAVEN:
plane = DataReader.readInt(data[0], data[1], data[2], data[3]);
texture = DataReader.readInt(data[4], data[5], data[6], data[7]);
face = DataReader.readInt(data[8], data[9], data[10], data[11]);
break;
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_DMOMAM:
this.displacement = DataReader.readShort(data[4], data[5]);
this.bevel = (sbyte)data[6]; // In little endian format, this byte takes the least significant bits of a short
// and can therefore be used for all Source engine formats, including Portal 2.
goto case mapType.TYPE_SIN;
case mapType.TYPE_SIN:
case mapType.TYPE_QUAKE2:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_SOF:
plane = DataReader.readUShort(data[0], data[1]);
texture = (int) DataReader.readShort(data[2], data[3]);
break;
case mapType.TYPE_VINDICTUS:
plane = DataReader.readInt(data[0], data[1], data[2], data[3]);
texture = DataReader.readInt(data[4], data[5], data[6], data[7]);
displacement = DataReader.readInt(data[8], data[9], data[10], data[11]);
bevel = (sbyte)data[12];
break;
case mapType.TYPE_NIGHTFIRE:
face = DataReader.readInt(data[0], data[1], data[2], data[3]);
plane = DataReader.readInt(data[4], data[5], data[6], data[7]);
break;
}
}
public static Lump <Plane> createLump(byte[] data, mapType type)
{
int structLength = 0;
switch (type)
{
case mapType.TYPE_QUAKE:
case mapType.TYPE_NIGHTFIRE:
case mapType.TYPE_SIN:
case mapType.TYPE_SOF:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_DMOMAM:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_QUAKE2:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_TACTICALINTERVENTION:
structLength = 20;
break;
case mapType.TYPE_STEF2:
case mapType.TYPE_MOHAA:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_RAVEN:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_FAKK:
case mapType.TYPE_COD:
case mapType.TYPE_COD2:
case mapType.TYPE_COD4:
structLength = 16;
break;
default:
structLength = 0; // This will cause the shit to hit the fan.
break;
}
int offset = 0;
Lump <Plane> lump = new Lump <Plane>(data.Length, structLength, data.Length / structLength);
byte[] bytes = new byte[structLength];
for (int i = 0; i < data.Length / structLength; i++)
{
for (int j = 0; j < structLength; j++)
{
bytes[j] = data[offset + j];
}
lump.Add(new Plane(bytes, type));
offset += structLength;
}
return(lump);
}
// METHODS
public static Lump<Leaf> createLump(byte[] data, mapType type) {
int structLength=0;
switch(type) {
case mapType.TYPE_QUAKE:
case mapType.TYPE_QUAKE2:
case mapType.TYPE_SIN:
structLength=28;
break;
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_SOF:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_DMOMAM:
structLength=32;
break;
case mapType.TYPE_VINDICTUS:
structLength=56;
break;
case mapType.TYPE_COD:
structLength=36;
break;
case mapType.TYPE_NIGHTFIRE:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_FAKK:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_STEF2:
case mapType.TYPE_RAVEN:
structLength=48;
break;
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
structLength=56;
break;
case mapType.TYPE_MOHAA:
structLength=64;
break;
default:
structLength=0; // This will cause the shit to hit the fan.
break;
}
int offset=0;
Lump<Leaf> lump = new Lump<Leaf>(data.Length, structLength, data.Length / structLength);
byte[] bytes=new byte[structLength];
for(int i=0;i<data.Length / structLength;i++) {
for(int j=0;j<structLength;j++) {
bytes[j]=data[offset+j];
}
lump.Add(new Leaf(bytes, type));
offset+=structLength;
}
return lump;
}
public SourceStaticProp(byte[] data, mapType type, int version) : base(data)
{
switch (type)
{
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
switch (version)
{
case 5:
if (data.Length == 188)
{
// This is only for The Ship or Bloody Good Time.
byte[] targetnameBytes = new byte[128];
for (int i = 0; i < 128; i++)
{
targetnameBytes[i] = data[60 + i];
}
targetname = DataReader.readNullTerminatedString(targetnameBytes);
if (targetname.Length == 0)
{
targetname = null;
}
}
goto case 6;
case 6:
case 7:
case 8:
case 9:
case 10:
forcedFadeScale = DataReader.readFloat(data[56], data[57], data[58], data[59]);
goto case 4;
case 4:
origin = DataReader.readPoint3F(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]);
angles = DataReader.readPoint3F(data[12], data[13], data[14], data[15], data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23]);
dictionaryEntry = DataReader.readShort(data[24], data[25]);
solidity = data[30];
flags = data[31];
skin = DataReader.readInt(data[32], data[33], data[34], data[35]);
minFadeDist = DataReader.readFloat(data[36], data[37], data[38], data[39]);
maxFadeDist = DataReader.readFloat(data[40], data[41], data[42], data[43]);
break;
}
break;
}
}
public BSPReader(FileInfo file, mapType readAs) {
this.readAs = readAs;
BSPFile = file;
if (!File.Exists(BSPFile.FullName)) {
DecompilerThread.OnMessage(this, "Unable to open BSP file; file "+BSPFile.FullName+" not found.");
} else {
this.stream = new FileStream(BSPFile.FullName, FileMode.Open, FileAccess.Read);
this.br = new BinaryReader(this.stream);
}
}
public Model(byte[] data, mapType type) : base(data)
{
switch (type)
{
case mapType.TYPE_QUAKE:
firstFace = DataReader.readInt(data[56], data[57], data[58], data[59]);
numFaces = DataReader.readInt(data[60], data[61], data[62], data[63]);
goto case mapType.TYPE_QUAKE2;
case mapType.TYPE_QUAKE2:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_SIN:
case mapType.TYPE_SOF:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
// In all these formats, the "head node" index comes after 9 floats.
headNode = DataReader.readInt(data[36], data[37], data[38], data[39]);
break;
case mapType.TYPE_DMOMAM:
headNode = DataReader.readInt(data[40], data[41], data[42], data[43]);
break;
case mapType.TYPE_NIGHTFIRE:
firstLeaf = DataReader.readInt(data[40], data[41], data[42], data[43]);
numLeaves = DataReader.readInt(data[44], data[45], data[46], data[47]);
break;
case mapType.TYPE_STEF2:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_MOHAA:
case mapType.TYPE_RAVEN:
case mapType.TYPE_FAKK:
firstBrush = DataReader.readInt(data[32], data[33], data[34], data[35]);
numBrushes = DataReader.readInt(data[36], data[37], data[38], data[39]);
break;
case mapType.TYPE_COD:
case mapType.TYPE_COD2:
case mapType.TYPE_COD4:
firstBrush = DataReader.readInt(data[40], data[41], data[42], data[43]);
numBrushes = DataReader.readInt(data[44], data[45], data[46], data[47]);
break;
}
}
public Brush(byte[] data, mapType type) : base(data)
{
switch (type)
{
case mapType.TYPE_QUAKE2:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_SIN:
case mapType.TYPE_SOF:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_DMOMAM:
firstSide = DataReader.readInt(data[0], data[1], data[2], data[3]);
numSides = DataReader.readInt(data[4], data[5], data[6], data[7]);
contents = new byte[] { data[8], data[9], data[10], data[11] };
break;
case mapType.TYPE_NIGHTFIRE:
contents = new byte[] { data[0], data[1], data[2], data[3] };
firstSide = DataReader.readInt(data[4], data[5], data[6], data[7]);
numSides = DataReader.readInt(data[8], data[9], data[10], data[11]);
break;
case mapType.TYPE_MOHAA:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_RAVEN:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_FAKK:
firstSide = DataReader.readInt(data[0], data[1], data[2], data[3]);
numSides = DataReader.readInt(data[4], data[5], data[6], data[7]);
texture = DataReader.readInt(data[8], data[9], data[10], data[11]);
break;
case mapType.TYPE_STEF2:
numSides = DataReader.readInt(data[0], data[1], data[2], data[3]);
firstSide = DataReader.readInt(data[4], data[5], data[6], data[7]);
texture = DataReader.readInt(data[8], data[9], data[10], data[11]);
break;
case mapType.TYPE_COD:
case mapType.TYPE_COD2:
case mapType.TYPE_COD4:
numSides = DataReader.readUShort(data[0], data[1]);
texture = DataReader.readUShort(data[2], data[3]);
break;
}
}
/// <summary>
/// 更换地图
/// </summary>
/// <param name="m"></param>
void ChangeMap(mapType m)
{
//tiles.GetComponent<Image>().sprite = Resources.Load<Sprite>("PNG/Tiles/Terrain" + m.ToString()+"/"+m.ToString().ToLower()+"_"+ num.ToString());
foreach (Transform item in transform)
{
int num = UnityEngine.Random.Range(1, 19);
string path = "Terrain/" + m.ToString() + "/" + m.ToString().ToLower() + "_" + num.ToString("d2");
Sprite s = Resources.Load <Sprite>(path);
item.GetComponent <Image>().sprite = s;
}
}
// METHODS
// createLump(byte[], uint)
// Parses a byte array into a Lump object containing Brushes.
public static Lump <Brush> createLump(byte[] inBytes, mapType type)
{
int structLength = 0;
switch (type)
{
case mapType.TYPE_QUAKE2:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_SIN:
case mapType.TYPE_SOF:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
case mapType.TYPE_NIGHTFIRE:
case mapType.TYPE_STEF2:
case mapType.TYPE_MOHAA:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_RAVEN:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_FAKK:
structLength = 12;
break;
case mapType.TYPE_COD:
case mapType.TYPE_COD2:
case mapType.TYPE_COD4:
structLength = 4;
break;
}
int offset = 0;
Lump <Brush> lump = new Lump <Brush>(inBytes.Length, structLength, inBytes.Length / structLength);
byte[] bytes = new byte[structLength];
for (int i = 0; i < inBytes.Length / structLength; i++)
{
for (int j = 0; j < structLength; j++)
{
bytes[j] = inBytes[offset + j];
}
lump.Add(new Brush(bytes, type));
offset += structLength;
}
return(lump);
}
public Leaf(byte[] data, mapType type):base(data) {
switch(type) {
case mapType.TYPE_SOF:
contents=new byte[] { data[0], data[1], data[2], data[3] };
firstMarkFace=DataReader.readUShort(data[22], data[23]);
numMarkFaces=DataReader.readUShort(data[24], data[25]);
firstMarkBrush=DataReader.readUShort(data[26], data[27]);
numMarkBrushes=DataReader.readUShort(data[28], data[29]);
break;
case mapType.TYPE_QUAKE2:
case mapType.TYPE_SIN:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_DMOMAM:
case mapType.TYPE_DAIKATANA:
contents=new byte[] { data[0], data[1], data[2], data[3] };
firstMarkBrush=DataReader.readUShort(data[24], data[25]);
numMarkBrushes=DataReader.readUShort(data[26], data[27]);
goto case mapType.TYPE_QUAKE;
case mapType.TYPE_QUAKE:
firstMarkFace=DataReader.readUShort(data[20], data[21]);
numMarkFaces=DataReader.readUShort(data[22], data[23]);
break;
case mapType.TYPE_VINDICTUS:
contents=new byte[] { data[0], data[1], data[2], data[3] };
firstMarkBrush=DataReader.readInt(data[44], data[45], data[46], data[47]);
numMarkBrushes=DataReader.readInt(data[48], data[49], data[50], data[51]);
break;
case mapType.TYPE_NIGHTFIRE:
contents=new byte[] { data[0], data[1], data[2], data[3] };
goto case mapType.TYPE_RAVEN;
case mapType.TYPE_QUAKE3:
case mapType.TYPE_FAKK:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_STEF2:
case mapType.TYPE_MOHAA:
case mapType.TYPE_RAVEN:
firstMarkFace=DataReader.readInt(data[32], data[33], data[34], data[35]);
numMarkFaces=DataReader.readInt(data[36], data[37], data[38], data[39]);
firstMarkBrush=DataReader.readInt(data[40], data[41], data[42], data[43]);
numMarkBrushes=DataReader.readInt(data[44], data[45], data[46], data[47]);
break;
}
}
public Texture(byte[] data, mapType type):base(data) {
switch (type) {
case mapType.TYPE_NIGHTFIRE:
name = DataReader.readNullTerminatedString(new byte[]{data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11], data[12], data[13], data[14], data[15], data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23], data[24], data[25], data[26], data[27], data[28], data[29], data[30], data[31], data[32], data[33], data[34], data[35], data[36], data[37], data[38], data[39], data[40], data[41], data[42], data[43], data[44], data[45], data[46], data[47], data[48], data[49], data[50], data[51], data[52], data[53], data[54], data[55], data[56], data[57], data[58], data[59], data[60], data[61], data[62], data[63]});
break;
case mapType.TYPE_QUAKE:
name = DataReader.readNullTerminatedString(new byte[]{data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11], data[12], data[13], data[14], data[15]});
break;
case mapType.TYPE_QUAKE2:
case mapType.TYPE_SOF:
case mapType.TYPE_DAIKATANA:
texAxes = new TexInfo(DataReader.readPoint3F(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]), DataReader.readFloat(data[12], data[13], data[14], data[15]), DataReader.readPoint3F(data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23], data[24], data[25], data[26], data[27]), DataReader.readFloat(data[28], data[29], data[30], data[31]), - 1, - 1);
flags = new byte[]{data[32], data[33], data[34], data[35]};
name = DataReader.readNullTerminatedString(new byte[]{data[40], data[41], data[42], data[43], data[44], data[45], data[46], data[47], data[48], data[49], data[50], data[51], data[52], data[53], data[54], data[55], data[56], data[57], data[58], data[59], data[60], data[61], data[62], data[63], data[64], data[65], data[66], data[67], data[68], data[69], data[70], data[71]});
break;
case mapType.TYPE_MOHAA:
mask = DataReader.readNullTerminatedString(new byte[]{data[76], data[77], data[78], data[79], data[80], data[81], data[82], data[83], data[84], data[85], data[86], data[87], data[88], data[89], data[90], data[91], data[92], data[93], data[94], data[95], data[96], data[97], data[98], data[99], data[100], data[101], data[102], data[103], data[104], data[105], data[106], data[107], data[108], data[109], data[110], data[111], data[112], data[113], data[114], data[115], data[116], data[117], data[118], data[119], data[120], data[121], data[122], data[123], data[124], data[125], data[126], data[127], data[128], data[129], data[130], data[131], data[132], data[133], data[134], data[135], data[136], data[137], data[138], data[139]});
goto case mapType.TYPE_STEF2;
case mapType.TYPE_STEF2:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_RAVEN:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_COD:
case mapType.TYPE_COD2:
case mapType.TYPE_COD4:
case mapType.TYPE_FAKK:
name = DataReader.readNullTerminatedString(new byte[]{data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11], data[12], data[13], data[14], data[15], data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23], data[24], data[25], data[26], data[27], data[28], data[29], data[30], data[31], data[32], data[33], data[34], data[35], data[36], data[37], data[38], data[39], data[40], data[41], data[42], data[43], data[44], data[45], data[46], data[47], data[48], data[49], data[50], data[51], data[52], data[53], data[54], data[55], data[56], data[57], data[58], data[59], data[60], data[61], data[62], data[63]});
flags = new byte[]{data[64], data[65], data[66], data[67]};
contents = new byte[]{data[68], data[69], data[70], data[71]};
break;
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
name = DataReader.readString(data);
break;
case mapType.TYPE_SIN:
texAxes = new TexInfo(DataReader.readPoint3F(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]), DataReader.readFloat(data[12], data[13], data[14], data[15]), DataReader.readPoint3F(data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23], data[24], data[25], data[26], data[27]), DataReader.readFloat(data[28], data[29], data[30], data[31]), - 1, - 1);
flags = new byte[]{data[32], data[33], data[34], data[35]};
name = DataReader.readNullTerminatedString(new byte[]{data[36], data[37], data[38], data[39], data[40], data[41], data[42], data[43], data[44], data[45], data[46], data[47], data[48], data[49], data[50], data[51], data[52], data[53], data[54], data[55], data[56], data[57], data[58], data[59], data[60], data[61], data[62], data[63], data[64], data[65], data[66], data[67], data[68], data[69], data[70], data[71], data[72], data[73], data[74], data[75], data[76], data[77], data[78], data[79], data[80], data[81], data[82], data[83], data[84], data[85], data[86], data[87], data[88], data[89], data[90], data[91], data[92], data[93], data[94], data[95], data[96], data[97], data[98], data[99]});
break;
}
}
public SourceStaticProp(byte[] data, mapType type, int version):base(data) {
switch (type) {
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
switch (version) {
case 5:
if (data.Length == 188) {
// This is only for The Ship or Bloody Good Time.
byte[] targetnameBytes = new byte[128];
for (int i = 0; i < 128; i++) {
targetnameBytes[i] = data[60 + i];
}
targetname = DataReader.readNullTerminatedString(targetnameBytes);
if (targetname.Length == 0) {
targetname = null;
}
}
goto case 6;
case 6:
case 7:
case 8:
case 9:
case 10:
forcedFadeScale = DataReader.readFloat(data[56], data[57], data[58], data[59]);
goto case 4;
case 4:
origin = DataReader.readPoint3F(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]);
angles = DataReader.readPoint3F(data[12], data[13], data[14], data[15], data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23]);
dictionaryEntry = DataReader.readShort(data[24], data[25]);
solidity = data[30];
flags = data[31];
skin = DataReader.readInt(data[32], data[33], data[34], data[35]);
minFadeDist = DataReader.readFloat(data[36], data[37], data[38], data[39]);
maxFadeDist = DataReader.readFloat(data[40], data[41], data[42], data[43]);
break;
}
break;
}
}
public Brush(byte[] data, mapType type):base(data) {
switch (type) {
case mapType.TYPE_QUAKE2:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_SIN:
case mapType.TYPE_SOF:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_DMOMAM:
firstSide = DataReader.readInt(data[0], data[1], data[2], data[3]);
numSides = DataReader.readInt(data[4], data[5], data[6], data[7]);
contents = new byte[]{data[8], data[9], data[10], data[11]};
break;
case mapType.TYPE_NIGHTFIRE:
contents = new byte[]{data[0], data[1], data[2], data[3]};
firstSide = DataReader.readInt(data[4], data[5], data[6], data[7]);
numSides = DataReader.readInt(data[8], data[9], data[10], data[11]);
break;
case mapType.TYPE_MOHAA:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_RAVEN:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_FAKK:
firstSide = DataReader.readInt(data[0], data[1], data[2], data[3]);
numSides = DataReader.readInt(data[4], data[5], data[6], data[7]);
texture = DataReader.readInt(data[8], data[9], data[10], data[11]);
break;
case mapType.TYPE_STEF2:
numSides = DataReader.readInt(data[0], data[1], data[2], data[3]);
firstSide = DataReader.readInt(data[4], data[5], data[6], data[7]);
texture = DataReader.readInt(data[8], data[9], data[10], data[11]);
break;
case mapType.TYPE_COD:
case mapType.TYPE_COD2:
case mapType.TYPE_COD4:
numSides = DataReader.readUShort(data[0], data[1]);
texture = DataReader.readUShort(data[2], data[3]);
break;
}
}
// METHODS
public static Lump <Edge> createLump(byte [] data, mapType type)
{
int structLength = 0;
switch (type)
{
case mapType.TYPE_QUAKE:
case mapType.TYPE_SIN:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_DMOMAM:
case mapType.TYPE_QUAKE2:
case mapType.TYPE_SOF:
structLength = 4;
break;
case mapType.TYPE_VINDICTUS:
structLength = 8;
break;
case mapType.TYPE_DOOM:
case mapType.TYPE_HEXEN:
structLength = 4;
break;
}
int offset = 0;
Lump <Edge> lump = new Lump <Edge>(data.Length, structLength, data.Length / structLength);
byte[] bytes = new byte[structLength];
for (int i = 0; i < data.Length / structLength; i++)
{
for (int j = 0; j < structLength; j++)
{
bytes[j] = data[offset + j];
}
lump.Add(new Edge(bytes, type));
offset += structLength;
}
return(lump);
}
// METHODS
public static Lump <SourceDispInfo> createLump(byte[] data, mapType type)
{
int structLength = 0;
switch (type)
{
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_DMOMAM:
structLength = 176;
break;
case mapType.TYPE_SOURCE22:
structLength = 180;
break;
case mapType.TYPE_SOURCE23:
structLength = 184;
break;
case mapType.TYPE_VINDICTUS:
structLength = 232;
break;
default:
structLength = 0; // This will cause the shit to hit the fan.
break;
}
int offset = 0;
Lump <SourceDispInfo> lump = new Lump <SourceDispInfo>(data.Length, structLength, data.Length / structLength);
byte[] bytes = new byte[structLength];
for (int i = 0; i < data.Length / structLength; i++)
{
for (int j = 0; j < structLength; j++)
{
bytes[j] = data[offset + j];
}
lump.Add(new SourceDispInfo(bytes, type));
offset += structLength;
}
return(lump);
}
public Model(byte[] data, mapType type):base(data) {
switch(type) {
case mapType.TYPE_QUAKE:
firstFace = DataReader.readInt(data[56], data[57], data[58], data[59]);
numFaces = DataReader.readInt(data[60], data[61], data[62], data[63]);
goto case mapType.TYPE_QUAKE2;
case mapType.TYPE_QUAKE2:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_SIN:
case mapType.TYPE_SOF:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
// In all these formats, the "head node" index comes after 9 floats.
headNode = DataReader.readInt(data[36], data[37], data[38], data[39]);
break;
case mapType.TYPE_DMOMAM:
headNode = DataReader.readInt(data[40], data[41], data[42], data[43]);
break;
case mapType.TYPE_NIGHTFIRE:
firstLeaf = DataReader.readInt(data[40], data[41], data[42], data[43]);
numLeaves = DataReader.readInt(data[44], data[45], data[46], data[47]);
break;
case mapType.TYPE_STEF2:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_MOHAA:
case mapType.TYPE_RAVEN:
case mapType.TYPE_FAKK:
firstBrush = DataReader.readInt(data[32], data[33], data[34], data[35]);
numBrushes = DataReader.readInt(data[36], data[37], data[38], data[39]);
break;
case mapType.TYPE_COD:
case mapType.TYPE_COD2:
case mapType.TYPE_COD4:
firstBrush = DataReader.readInt(data[40], data[41], data[42], data[43]);
numBrushes = DataReader.readInt(data[44], data[45], data[46], data[47]);
break;
}
}
public static Lump <TexInfo> createLump(byte[] data, mapType type)
{
int structLength = 0;
switch (type)
{
case mapType.TYPE_NIGHTFIRE:
structLength = 32;
break;
case mapType.TYPE_QUAKE:
structLength = 40;
break;
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
structLength = 72;
break;
case mapType.TYPE_DMOMAM:
structLength = 96;
break;
}
int offset = 0;
Lump <TexInfo> lump = new Lump <TexInfo>(data.Length, structLength, data.Length / structLength);
byte[] bytes = new byte[structLength];
for (int i = 0; i < data.Length / structLength; i++)
{
for (int j = 0; j < structLength; j++)
{
bytes[j] = data[offset + j];
}
lump.Add(new TexInfo(bytes, type));
offset += structLength;
}
return(lump);
}
// METHODS
// createLump(byte[], uint)
// Parses a byte array into a Lump object containing Brushes.
public static Lump<Brush> createLump(byte[] inBytes, mapType type) {
int structLength = 0;
switch (type) {
case mapType.TYPE_QUAKE2:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_SIN:
case mapType.TYPE_SOF:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
case mapType.TYPE_NIGHTFIRE:
case mapType.TYPE_STEF2:
case mapType.TYPE_MOHAA:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_RAVEN:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_FAKK:
structLength = 12;
break;
case mapType.TYPE_COD:
case mapType.TYPE_COD2:
case mapType.TYPE_COD4:
structLength = 4;
break;
}
int offset = 0;
Lump<Brush> lump = new Lump<Brush>(inBytes.Length, structLength, inBytes.Length / structLength);
byte[] bytes = new byte[structLength];
for (int i = 0; i < inBytes.Length / structLength; i++) {
for (int j = 0; j < structLength; j++) {
bytes[j] = inBytes[offset + j];
}
lump.Add(new Brush(bytes, type));
offset += structLength;
}
return lump;
}
public SourceCubemap(byte[] data, mapType type):base(data) {
switch (type) {
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
origin = new Vector3D(DataReader.readInt(data[0], data[1], data[2], data[3]), DataReader.readInt(data[4], data[5], data[6], data[7]), DataReader.readInt(data[8], data[9], data[10], data[11]));
size = DataReader.readInt(data[12], data[13], data[14], data[15]);
break;
}
}
// Use this for initialization
void Start()
{
GameManager.instance.mapMaker = this;
if (GameManager.instance.mapMode == 0)
{
mapTypeSelection = mapType.mapOfTheDay;
}
else if (GameManager.instance.mapMode == 1)
{
mapTypeSelection = mapType.randomMap;
}
else
{
mapTypeSelection = mapType.seededMap;
seedValue = GameManager.instance.seedNum;
}
generateMap();
}
public Map LoadMap(mapType mapType)
{
var map = SqlHelper.GetMap(mapType);
foreach (Row row in map.Rows)
{
foreach (Cell cell in row.Cells)
{
var block = GameObject.Find(cell.X + "-" + cell.Y);
block.GetComponent <SpriteRenderer>().sprite = blockSprites[cell.Sprite];
if (cell.Bridge)
{
Instantiate(bridge, block.transform.position, Quaternion.identity, block.transform);
}
block.GetComponent <block>().LoadValues();
}
}
return(map);
}
public SourceCubemap(byte[] data, mapType type) : base(data)
{
switch (type)
{
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
origin = new Vector3D(DataReader.readInt(data[0], data[1], data[2], data[3]), DataReader.readInt(data[4], data[5], data[6], data[7]), DataReader.readInt(data[8], data[9], data[10], data[11]));
size = DataReader.readInt(data[12], data[13], data[14], data[15]);
break;
}
}
public Node(byte[] data, mapType type) : base(data)
{
this.plane = DataReader.readInt(data[0], data[1], data[2], data[3]); // All formats I've seen use the first 4 bytes as an int, plane index
switch (type)
{
// I don't actually need to read or store node information for most of these formats.
// Support for them is only provided for completeness and consistency.
case mapType.TYPE_QUAKE:
this.child1 = (int)DataReader.readShort(data[4], data[5]);
this.child2 = (int)DataReader.readShort(data[6], data[7]);
break;
// Nightfire, Source, Quake 2 and Quake 3-based engines all use the first three ints for planenum and children
case mapType.TYPE_SIN:
case mapType.TYPE_SOF:
case mapType.TYPE_QUAKE2:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_NIGHTFIRE:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
case mapType.TYPE_STEF2:
case mapType.TYPE_MOHAA:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_RAVEN:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_FAKK:
case mapType.TYPE_COD:
this.child1 = DataReader.readInt(data[4], data[5], data[6], data[7]);
this.child2 = DataReader.readInt(data[8], data[9], data[10], data[11]);
break;
}
}
public Vertex(byte[] data, mapType type) : base(data)
{
switch (type)
{
case mapType.TYPE_DOOM:
case mapType.TYPE_HEXEN:
vertex = new Vector3D(DataReader.readShort(data[0], data[1]), DataReader.readShort(data[2], data[3]));
break;
case mapType.TYPE_STEF2:
case mapType.TYPE_MOHAA:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_RAVEN:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_COD:
case mapType.TYPE_FAKK:
texCoord[0] = DataReader.readFloat(data[12], data[13], data[14], data[15]);
texCoord[1] = DataReader.readFloat(data[16], data[17], data[18], data[19]);
goto case mapType.TYPE_QUAKE;
case mapType.TYPE_QUAKE:
case mapType.TYPE_NIGHTFIRE:
case mapType.TYPE_SIN:
case mapType.TYPE_SOF:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_QUAKE2:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
vertex = DataReader.readPoint3F(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]);
break;
}
}
// METHODS
public static Lump<Edge> createLump(byte [] data, mapType type) {
int structLength = 0;
switch (type) {
case mapType.TYPE_QUAKE:
case mapType.TYPE_SIN:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_DMOMAM:
case mapType.TYPE_QUAKE2:
case mapType.TYPE_SOF:
structLength = 4;
break;
case mapType.TYPE_VINDICTUS:
structLength = 8;
break;
case mapType.TYPE_DOOM:
case mapType.TYPE_HEXEN:
structLength = 4;
break;
}
int offset = 0;
Lump<Edge> lump = new Lump<Edge>(data.Length, structLength, data.Length / structLength);
byte[] bytes = new byte[structLength];
for (int i = 0; i < data.Length / structLength; i++) {
for (int j = 0; j < structLength; j++) {
bytes[j] = data[offset + j];
}
lump.Add(new Edge(bytes, type));
offset += structLength;
}
return lump;
}
// This constructor takes bytes in a byte array, as though
// it had just been read by a FileInputStream.
public SourceDispInfo(byte[] data, mapType type) : base(data)
{
startPosition = DataReader.readPoint3F(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]);
dispVertStart = DataReader.readInt(data[12], data[13], data[14], data[15]);
//dispTriStart=DataReader.readInt(in[16], in[17], in[18], in[19]);
power = DataReader.readInt(data[20], data[21], data[22], data[23]);
allowedVerts = new uint[10];
int offset = 0;
switch (type)
{
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_DMOMAM:
offset = 136;
break;
case mapType.TYPE_SOURCE22:
offset = 140;
break;
case mapType.TYPE_SOURCE23:
offset = 144;
break;
case mapType.TYPE_VINDICTUS:
offset = 192;
break;
}
for (int i = 0; i < 10; i++)
{
allowedVerts[i] = DataReader.readUInt(data[offset + (i * 4)], data[offset + 1 + (i * 4)], data[offset + 2 + (i * 4)], data[offset + 3 + (i * 4)]);
}
}
// METHODS
//UPGRADE_ISSUE: The following fragment of code could not be parsed and was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextSettingsIndex'&keyword='jlca1156'"
public static Lump<DThing> createLump(byte[] data, mapType type) {
int structLength = 0;
switch (type) {
case mapType.TYPE_DOOM:
structLength = 10;
break;
case mapType.TYPE_HEXEN:
structLength = 20;
break;
}
int offset = 0;
Lump<DThing> lump = new Lump<DThing>(data.Length, structLength, data.Length / structLength);
byte[] bytes = new byte[structLength];
for (int i = 0; i < data.Length / structLength; i++) {
for (int j = 0; j < structLength; j++) {
bytes[j] = data[offset + j];
}
lump.Add(new DThing(bytes, type));
offset += structLength;
}
return lump;
}
public Node(byte[] data, mapType type):base(data) {
this.plane = DataReader.readInt(data[0], data[1], data[2], data[3]); // All formats I've seen use the first 4 bytes as an int, plane index
switch (type) {
// I don't actually need to read or store node information for most of these formats.
// Support for them is only provided for completeness and consistency.
case mapType.TYPE_QUAKE:
this.child1 = (int) DataReader.readShort(data[4], data[5]);
this.child2 = (int) DataReader.readShort(data[6], data[7]);
break;
// Nightfire, Source, Quake 2 and Quake 3-based engines all use the first three ints for planenum and children
case mapType.TYPE_SIN:
case mapType.TYPE_SOF:
case mapType.TYPE_QUAKE2:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_NIGHTFIRE:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
case mapType.TYPE_STEF2:
case mapType.TYPE_MOHAA:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_RAVEN:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_FAKK:
case mapType.TYPE_COD:
this.child1 = DataReader.readInt(data[4], data[5], data[6], data[7]);
this.child2 = DataReader.readInt(data[8], data[9], data[10], data[11]);
break;
}
}
public TexInfo(byte[] data, mapType type) : base(data)
{
axes = new Vector3D[2];
axes[S] = DataReader.readPoint3F(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]);
shifts[S] = DataReader.readFloat(data[12], data[13], data[14], data[15]);
axes[T] = DataReader.readPoint3F(data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23], data[24], data[25], data[26], data[27]);
shifts[T] = DataReader.readFloat(data[28], data[29], data[30], data[31]);
switch (type)
{
// Excluded engines: Quake 2-based, Quake 3-based
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
texture = DataReader.readInt(data[68], data[69], data[70], data[71]);
flags = DataReader.readInt(data[64], data[65], data[66], data[67]);
break;
case mapType.TYPE_DMOMAM:
texture = DataReader.readInt(data[92], data[93], data[94], data[95]);
flags = DataReader.readInt(data[88], data[89], data[90], data[91]);
break;
case mapType.TYPE_QUAKE:
texture = DataReader.readInt(data[32], data[33], data[34], data[35]);
flags = DataReader.readInt(data[36], data[37], data[38], data[39]);
break;
case mapType.TYPE_NIGHTFIRE:
break;
}
}
public DThing(byte[] data, mapType type):base(data) {
switch (type) {
case mapType.TYPE_DOOM:
origin = new Vector3D(DataReader.readShort(data[0], data[1]), DataReader.readShort(data[2], data[3]));
this.angle = DataReader.readShort(data[4], data[5]);
this.classNum = DataReader.readShort(data[6], data[7]);
this.flags = DataReader.readShort(data[8], data[9]);
break;
case mapType.TYPE_HEXEN:
id = DataReader.readShort(data[0], data[1]);
origin = new Vector3D(DataReader.readShort(data[2], data[3]), DataReader.readShort(data[4], data[5]), DataReader.readShort(data[6], data[7]));
this.angle = DataReader.readShort(data[8], data[9]);
this.classNum = DataReader.readShort(data[10], data[11]);
this.flags = DataReader.readShort(data[12], data[13]);
action = data[14];
arguments[0] = data[15];
arguments[1] = data[16];
arguments[2] = data[17];
arguments[3] = data[18];
arguments[4] = data[19];
break;
}
}
public DLinedef(byte[] data, mapType type):base(data) {
start = DataReader.readShort(data[0], data[1]);
end = DataReader.readShort(data[2], data[3]);
flags = new byte[]{data[4], data[5]};
switch (type) {
case mapType.TYPE_DOOM:
action = DataReader.readShort(data[6], data[7]);
tag = DataReader.readShort(data[8], data[9]);
right = DataReader.readShort(data[10], data[11]);
left = DataReader.readShort(data[12], data[13]);
break;
case mapType.TYPE_HEXEN:
action = data[6];
arguments[0] = data[7];
arguments[1] = data[8];
arguments[2] = data[9];
arguments[3] = data[10];
arguments[4] = data[11];
right = DataReader.readShort(data[12], data[13]);
left = DataReader.readShort(data[14], data[15]);
break;
}
}
public Vertex(byte[] data, mapType type):base(data) {
switch (type) {
case mapType.TYPE_DOOM:
case mapType.TYPE_HEXEN:
vertex = new Vector3D(DataReader.readShort(data[0], data[1]), DataReader.readShort(data[2], data[3]));
break;
case mapType.TYPE_STEF2:
case mapType.TYPE_MOHAA:
case mapType.TYPE_STEF2DEMO:
case mapType.TYPE_RAVEN:
case mapType.TYPE_QUAKE3:
case mapType.TYPE_COD:
case mapType.TYPE_FAKK:
texCoord[0] = DataReader.readFloat(data[12], data[13], data[14], data[15]);
texCoord[1] = DataReader.readFloat(data[16], data[17], data[18], data[19]);
goto case mapType.TYPE_QUAKE;
case mapType.TYPE_QUAKE:
case mapType.TYPE_NIGHTFIRE:
case mapType.TYPE_SIN:
case mapType.TYPE_SOF:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_QUAKE2:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_DMOMAM:
vertex = DataReader.readPoint3F(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]);
break;
}
}
public static Lump<TexInfo> createLump(byte[] data, mapType type) {
int structLength = 0;
switch (type) {
case mapType.TYPE_NIGHTFIRE:
structLength = 32;
break;
case mapType.TYPE_QUAKE:
structLength = 40;
break;
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_VINDICTUS:
structLength = 72;
break;
case mapType.TYPE_DMOMAM:
structLength = 96;
break;
}
int offset = 0;
Lump<TexInfo> lump = new Lump<TexInfo>(data.Length, structLength, data.Length / structLength);
byte[] bytes = new byte[structLength];
for (int i = 0; i < data.Length / structLength; i++) {
for (int j = 0; j < structLength; j++) {
bytes[j] = data[offset + j];
}
lump.Add(new TexInfo(bytes, type));
offset += structLength;
}
return lump;
}
public Node(LumpObject data, mapType type) : base(data.Data)
{
new Node(data.Data, type);
}
public DecompilerThread(DoomMap doomMap, int jobNum, mapType openAs) {
this.doomMap = doomMap;
this.jobnum = jobNum;
}
public TexInfo(LumpObject data, mapType type) : base(data.Data)
{
new TexInfo(data.Data, type);
}
// CONSTRUCTORS
public VMFWriter(Entities from, string to, mapType BSPVersion) {
this.data = from;
this.path = to;
this.BSPVersion = BSPVersion;
}
public void resetMap(mapType mode, bool Cache, bool setRes = true)
{
mType = mode;
cache = Cache;
resetMap(setRes);
}
// METHODS
public static SourceStaticProps createLump(byte[] data, mapType type, int version) {
int structLength = 0;
string[] dictionary = new string[0];
SourceStaticProps lump;
if (data.Length > 0) {
/*switch(type) { // It's possible to determine structlength using arithmetic rather than version numbering
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
switch(version) {
case 4:
structLength=56;
break;
case 5:
structLength=60;
break;
case 6:
structLength=64;
break;
case 7:
structLength=68;
break;
case 8:
structLength=72;
break;
case 9:
structLength=73; // ??? The last entry is a boolean, is it stored as a byte?
break;
default:
structLength=0;
break;
default:
structLength=0;
}*/
int offset = 0;
dictionary = new string[DataReader.readInt(data[offset++], data[offset++], data[offset++], data[offset++])];
for (int i = 0; i < dictionary.Length; i++) {
byte[] temp = new byte[128];
for (int j = 0; j < 128; j++) {
temp[j] = data[offset++];
}
dictionary[i] = DataReader.readNullTerminatedString(temp);
}
int numLeafDefinitions = DataReader.readInt(data[offset++], data[offset++], data[offset++], data[offset++]);
for (int i = 0; i < numLeafDefinitions; i++) {
offset += 2; // Each leaf index is an unsigned short, which i just want to skip
}
int numProps = DataReader.readInt(data[offset++], data[offset++], data[offset++], data[offset++]);
lump = new SourceStaticProps(new List<SourceStaticProp>(numProps), dictionary, data.Length);
if (numProps > 0) {
structLength = (data.Length - offset) / numProps;
byte[] bytes = new byte[structLength];
for (int i = 0; i < numProps; i++) {
for (int j = 0; j < structLength; j++) {
bytes[j] = data[offset + j];
}
lump.Add(new SourceStaticProp(bytes, type, version));
offset += structLength;
}
}
} else {
lump = new SourceStaticProps(new List<SourceStaticProp>(), dictionary, data.Length);
}
return lump;
}
public TexInfo(LumpObject data, mapType type):base(data.Data) {
new TexInfo(data.Data, type);
}
// METHODS
public static SourceStaticProps createLump(byte[] data, mapType type, int version)
{
int structLength = 0;
string[] dictionary = new string[0];
SourceStaticProps lump;
if (data.Length > 0)
{
/*switch(type) { // It's possible to determine structlength using arithmetic rather than version numbering
* case mapType.TYPE_SOURCE17:
* case mapType.TYPE_SOURCE18:
* case mapType.TYPE_SOURCE19:
* case mapType.TYPE_SOURCE20:
* case mapType.TYPE_SOURCE21:
* case mapType.TYPE_SOURCE22:
* case mapType.TYPE_SOURCE23:
* switch(version) {
* case 4:
* structLength=56;
* break;
* case 5:
* structLength=60;
* break;
* case 6:
* structLength=64;
* break;
* case 7:
* structLength=68;
* break;
* case 8:
* structLength=72;
* break;
* case 9:
* structLength=73; // ??? The last entry is a boolean, is it stored as a byte?
* break;
* default:
* structLength=0;
* break;
* default:
* structLength=0;
* }*/
int offset = 0;
dictionary = new string[DataReader.readInt(data[offset++], data[offset++], data[offset++], data[offset++])];
for (int i = 0; i < dictionary.Length; i++)
{
byte[] temp = new byte[128];
for (int j = 0; j < 128; j++)
{
temp[j] = data[offset++];
}
dictionary[i] = DataReader.readNullTerminatedString(temp);
}
int numLeafDefinitions = DataReader.readInt(data[offset++], data[offset++], data[offset++], data[offset++]);
for (int i = 0; i < numLeafDefinitions; i++)
{
offset += 2; // Each leaf index is an unsigned short, which i just want to skip
}
int numProps = DataReader.readInt(data[offset++], data[offset++], data[offset++], data[offset++]);
lump = new SourceStaticProps(new List <SourceStaticProp>(numProps), dictionary, data.Length);
if (numProps > 0)
{
structLength = (data.Length - offset) / numProps;
byte[] bytes = new byte[structLength];
for (int i = 0; i < numProps; i++)
{
for (int j = 0; j < structLength; j++)
{
bytes[j] = data[offset + j];
}
lump.Add(new SourceStaticProp(bytes, type, version));
offset += structLength;
}
}
}
else
{
lump = new SourceStaticProps(new List <SourceStaticProp>(), dictionary, data.Length);
}
return(lump);
}
public Vertex(LumpObject data, mapType type) : base(data.Data)
{
new Vertex(data.Data, type);
}
public DecompilerThread(FileInfo BSPFile, int jobnum, mapType openAs) {
// Set up global variables
this.BSPFile = BSPFile;
this.jobnum = jobnum;
this.openAs = openAs;
}
public void readGameLump(byte[] gamelumpData, int gamelumpFileOffset) {
int numGamelumps = DataReader.readInt(gamelumpData[0], gamelumpData[1], gamelumpData[2], gamelumpData[3]);
int gamelumpOffset = 4;
if (version == mapType.TYPE_DMOMAM) {
if(readAs == mapType.TYPE_UNDEFINED) {
int next4 = DataReader.readInt(gamelumpData[4], gamelumpData[5], gamelumpData[6], gamelumpData[7]);
if (next4 == 1) {
gamelumpOffset += 4;
} else {
version = mapType.TYPE_SOURCE20;
BSPObject.Version = mapType.TYPE_SOURCE20;
}
} else {
gamelumpOffset += 4;
}
}
if (numGamelumps > 1) {
byte[] staticPropLump = new byte[0];
int staticPropLumpVersion = 0;
for (int i = 0; i < numGamelumps; i++) {
string gamelumpID = DataReader.readString(new byte[] { gamelumpData[gamelumpOffset], gamelumpData[gamelumpOffset + 1], gamelumpData[gamelumpOffset + 2], gamelumpData[gamelumpOffset + 3] } );
int gamelumpVersion = (int) DataReader.readShort(gamelumpData[gamelumpOffset + 6], gamelumpData[gamelumpOffset + 7]);
int internalOffset = DataReader.readInt(gamelumpData[gamelumpOffset + 8], gamelumpData[gamelumpOffset + 9], gamelumpData[gamelumpOffset + 10], gamelumpData[gamelumpOffset + 11]);
int internalLength = DataReader.readInt(gamelumpData[gamelumpOffset + 12], gamelumpData[gamelumpOffset + 13], gamelumpData[gamelumpOffset + 14], gamelumpData[gamelumpOffset + 15]);
if ((internalOffset < 4 + (16 * numGamelumps) && version == mapType.TYPE_SOURCE20 && readAs == mapType.TYPE_UNDEFINED) || version == mapType.TYPE_VINDICTUS || readAs == mapType.TYPE_VINDICTUS) {
// Even if the offset is relative to start of game lump, it will never be below this. If it is, it uses this format instead.
BSPObject.Version = mapType.TYPE_VINDICTUS;
version = mapType.TYPE_VINDICTUS;
gamelumpVersion = DataReader.readInt(gamelumpData[gamelumpOffset + 8], gamelumpData[gamelumpOffset + 9], gamelumpData[gamelumpOffset + 10], gamelumpData[gamelumpOffset + 11]);
internalOffset = DataReader.readInt(gamelumpData[gamelumpOffset + 12], gamelumpData[gamelumpOffset + 13], gamelumpData[gamelumpOffset + 14], gamelumpData[gamelumpOffset + 15]);
internalLength = DataReader.readInt(gamelumpData[gamelumpOffset + 16], gamelumpData[gamelumpOffset + 17], gamelumpData[gamelumpOffset + 18], gamelumpData[gamelumpOffset + 19]);
gamelumpOffset += 20;
} else {
gamelumpOffset += 16;
if (version == mapType.TYPE_DMOMAM) {
gamelumpOffset += 4;
}
}
if (internalOffset < gamelumpFileOffset) {
internalOffset += gamelumpFileOffset;
}
if (gamelumpID.Equals("prps", StringComparison.InvariantCultureIgnoreCase)) {
staticPropLumpVersion = gamelumpVersion;
staticPropLump = readLump(internalOffset, internalLength);
BSPObject.StaticProps = SourceStaticProp.createLump(staticPropLump, version, staticPropLumpVersion);
}
// Other game lumps would go here
}
}
}
// METHODS
public void readBSP() {
try {
version = Version;
byte[] theLump = new byte[0];
BSPObject = new BSP(BSPFile.FullName, version);
switch(version) {
case mapType.TYPE_VINDICTUS:
case mapType.TYPE_TACTICALINTERVENTION:
case mapType.TYPE_SOURCE17:
case mapType.TYPE_SOURCE18:
case mapType.TYPE_SOURCE19:
case mapType.TYPE_SOURCE20:
case mapType.TYPE_SOURCE21:
case mapType.TYPE_SOURCE22:
case mapType.TYPE_SOURCE23:
case mapType.TYPE_SOURCE27:
case mapType.TYPE_DMOMAM:
DecompilerThread.OnMessage(this, "Source BSP");
stream.Seek(8, SeekOrigin.Begin);
int test = br.ReadInt32();
if(bigEndian) { test = DataReader.swapEndian(test); }
if(test < 1032) { // If what's usually the offset is less than the length of the header and directory
isL4D2 = true; // This is Left 4 Dead 2
}
// Lump 35, Game lump
// Need to handle this here in order to detect Vindictus maps.
// This lump SUCKS. It's a lump containing nested lumps for game specific data.
// What we need out of it is the static prop lump.
theLump = readLumpNum(35);
try {
readGameLump(theLump, lumpOffset);
} catch {
dumpLump(theLump);
}
for(int i=0;i<64;i++) {
try {
switch(i) {
case 0:
theLump = readLumpNum(i);
BSPObject.Entities = Entity.createLump(theLump);
break;
case 1:
theLump = readLumpNum(i);
BSPObject.Planes = Plane.createLump(theLump, version);
break;
case 2:
theLump = readLumpNum(i);
BSPObject.TexDatas = SourceTexData.createLump(theLump);
break;
case 3:
theLump = readLumpNum(i);
BSPObject.Vertices = Vertex.createLump(theLump, version);
break;
case 5:
theLump = readLumpNum(i);
BSPObject.Nodes = Node.createLump(theLump, version);
break;
case 6:
theLump = readLumpNum(i);
BSPObject.TexInfo = TexInfo.createLump(theLump, version);
break;
case 7:
theLump = readLumpNum(i);
BSPObject.Faces = Face.createLump(theLump, version);
break;
case 10:
theLump = readLumpNum(i);
BSPObject.Leaves = Leaf.createLump(theLump, version);
break;
case 12:
theLump = readLumpNum(i);
BSPObject.Edges = Edge.createLump(theLump, version);
break;
case 13:
theLump = readLumpNum(i);
BSPObject.SurfEdges = new NumList(theLump, NumList.dataType.INT);
break;
case 14:
theLump = readLumpNum(i);
BSPObject.Models = Model.createLump(theLump, version);
break;
case 17:
theLump = readLumpNum(i);
if(version == mapType.TYPE_VINDICTUS) {
BSPObject.MarkBrushes = new NumList(theLump, NumList.dataType.UINT);
} else {
BSPObject.MarkBrushes = new NumList(theLump, NumList.dataType.USHORT);
}
break;
case 18:
theLump = readLumpNum(i);
BSPObject.Brushes = Brush.createLump(theLump, version);
break;
case 19:
theLump = readLumpNum(i);
BSPObject.BrushSides = BrushSide.createLump(theLump, version);
break;
case 26:
theLump = readLumpNum(i);
BSPObject.DispInfos = SourceDispInfo.createLump(theLump, version);
break;
case 27:
theLump = readLumpNum(i);
BSPObject.OriginalFaces = Face.createLump(theLump, version);
break;
case 33:
theLump = readLumpNum(i);
BSPObject.DispVerts = SourceDispVertex.createLump(theLump);
break;
case 40:
theLump = readLumpNum(i);
if (Settings.extractZip) {
Console.Write("Extracting internal PAK file... ");
writeLump(BSPObject.MapName+".zip", theLump);
}
break;
case 42:
theLump = readLumpNum(i);
BSPObject.Cubemaps = SourceCubemap.createLump(theLump, version);
break;
case 43:
theLump = readLumpNum(i);
BSPObject.Textures = Texture.createLump(theLump, version);
break;
case 44:
theLump = readLumpNum(i);
BSPObject.TexTable = new NumList(theLump, NumList.dataType.INT);
break;
case 48:
theLump = readLumpNum(i);
BSPObject.DispTris = new NumList(theLump, NumList.dataType.USHORT);
break;
}
} catch {
dumpLump(theLump);
}
}
break;
case mapType.TYPE_NIGHTFIRE:
DecompilerThread.OnMessage(this, "BSP v42 (Nightfire)");
for(int i=0;i<18;i++) {
try {
switch(i) {
case 0:
theLump = readLumpNum(i);
BSPObject.Entities = Entity.createLump(theLump);
break;
case 1:
theLump = readLumpNum(i);
BSPObject.Planes = Plane.createLump(theLump, version);
break;
case 2:
theLump = readLumpNum(i);
BSPObject.Textures = Texture.createLump(theLump, version);
break;
case 3:
theLump = readLumpNum(i);
BSPObject.Materials = Texture.createLump(theLump, version);
break;
case 4:
theLump = readLumpNum(i);
BSPObject.Vertices = Vertex.createLump(theLump, version);
break;
case 9:
theLump = readLumpNum(i);
BSPObject.Faces = Face.createLump(theLump, version);
break;
case 11:
theLump = readLumpNum(i);
BSPObject.Leaves = Leaf.createLump(theLump, version);
break;
case 13:
theLump = readLumpNum(i);
BSPObject.MarkBrushes = new NumList(theLump, NumList.dataType.UINT);
break;
case 14:
theLump = readLumpNum(i);
BSPObject.Models = Model.createLump(theLump, version);
break;
case 15:
theLump = readLumpNum(i);
BSPObject.Brushes = Brush.createLump(theLump, version);
break;
case 16:
theLump = readLumpNum(i);
BSPObject.BrushSides = BrushSide.createLump(theLump, version);
break;
case 17:
theLump = readLumpNum(i);
BSPObject.TexInfo = TexInfo.createLump(theLump, version);
break;
}
} catch {
dumpLump(theLump);
}
}
break;
case mapType.TYPE_QUAKE2:
case mapType.TYPE_SIN:
case mapType.TYPE_DAIKATANA:
case mapType.TYPE_SOF:
DecompilerThread.OnMessage(this, "BSP v38 (Quake 2/SiN/Daikatana/Soldier of Fortune)");
for(int i=0;i<19;i++) {
try {
switch(i) {
case 0:
theLump = readLumpNum(i);
BSPObject.Entities = Entity.createLump(theLump);
break;
case 1:
theLump = readLumpNum(i);
BSPObject.Planes = Plane.createLump(theLump, version);
break;
case 2:
theLump = readLumpNum(i);
BSPObject.Vertices = Vertex.createLump(theLump, version);
break;
case 4:
theLump = readLumpNum(i);
BSPObject.Nodes = Node.createLump(theLump, version);
break;
case 5:
theLump = readLumpNum(i);
BSPObject.Textures = Texture.createLump(theLump, version);
break;
case 6:
theLump = readLumpNum(i);
BSPObject.Faces = Face.createLump(theLump, version);
break;
case 8:
theLump = readLumpNum(i);
BSPObject.Leaves = Leaf.createLump(theLump, version);
break;
case 10:
theLump = readLumpNum(i);
BSPObject.MarkBrushes = new NumList(theLump, NumList.dataType.USHORT);
break;
case 11:
theLump = readLumpNum(i);
BSPObject.Edges = Edge.createLump(theLump, version);
break;
case 12:
theLump = readLumpNum(i);
BSPObject.SurfEdges = new NumList(theLump, NumList.dataType.INT);
break;
case 13:
theLump = readLumpNum(i);
BSPObject.Models = Model.createLump(theLump, version);
break;
case 14:
theLump = readLumpNum(i);
BSPObject.Brushes = Brush.createLump(theLump, version);
break;
case 15:
theLump = readLumpNum(i);
BSPObject.BrushSides = BrushSide.createLump(theLump, version);
break;
/*case 18:
theLump = readLumpNum(i);
BSPObject.AreaPortals = AreaPortal.createLump(theLump, version);
break;*/
}
} catch {
dumpLump(theLump);
}
}
break;
case mapType.TYPE_QUAKE:
DecompilerThread.OnMessage(this, "Quake 1/Half-life BSP");
for (int i = 0; i < 15; i++) {
try {
switch (i) {
case 0:
theLump = readLumpNum(i);
BSPObject.Entities = Entity.createLump(theLump);
break;
case 1:
theLump = readLumpNum(i);
BSPObject.Planes = Plane.createLump(theLump, version);
break;
case 2:
theLump = readLumpNum(i);
BSPObject.Textures = Texture.createLump(theLump, version);
break;
case 3:
theLump = readLumpNum(i);
BSPObject.Vertices = Vertex.createLump(theLump, version);
break;
case 5:
theLump = readLumpNum(i);
BSPObject.Nodes = Node.createLump(theLump, version);
break;
case 6:
theLump = readLumpNum(i);
BSPObject.TexInfo = TexInfo.createLump(theLump, version);
break;
case 7:
theLump = readLumpNum(i);
BSPObject.Faces = Face.createLump(theLump, version);
break;
case 10:
theLump = readLumpNum(i);
BSPObject.Leaves = Leaf.createLump(theLump, version);
break;
case 11:
theLump = readLumpNum(i);
BSPObject.MarkSurfaces = new NumList(theLump, NumList.dataType.USHORT);
break;
case 12:
theLump = readLumpNum(i);
BSPObject.Edges = Edge.createLump(theLump, version);
break;
case 13:
theLump = readLumpNum(i);
BSPObject.SurfEdges = new NumList(theLump, NumList.dataType.INT);
break;
case 14:
theLump = readLumpNum(i);
BSPObject.Models = Model.createLump(theLump, version);
break;
}
}
catch
{
dumpLump(theLump);
}
}
break;
case mapType.TYPE_STEF2:
case mapType.TYPE_STEF2DEMO:
DecompilerThread.OnMessage(this, "Star Trek Elite Force 2 BSP");
for (int i = 0; i < 30; i++) {
try {
switch (i) {
case 0:
theLump = readLumpNum(i);
BSPObject.Textures = Texture.createLump(theLump, version);
break;
case 1:
theLump = readLumpNum(i);
BSPObject.Planes = Plane.createLump(theLump, version);
break;
case 5:
theLump = readLumpNum(i);
BSPObject.Faces = Face.createLump(theLump, version);
break;
case 6:
theLump = readLumpNum(i);
BSPObject.Vertices = Vertex.createLump(theLump, version);
break;
case 12:
theLump = readLumpNum(i);
BSPObject.BrushSides = BrushSide.createLump(theLump, version);
break;
case 13:
theLump = readLumpNum(i);
BSPObject.Brushes = Brush.createLump(theLump, version);
break;
case 15:
theLump = readLumpNum(i);
BSPObject.Models = Model.createLump(theLump, version);
break;
case 16:
theLump = readLumpNum(i);
BSPObject.Entities = Entity.createLump(theLump);
break;
}
}
catch
{
dumpLump(theLump);
}
}
break;
case mapType.TYPE_MOHAA:
DecompilerThread.OnMessage(this, "MOHAA BSP (modified id Tech 3)");
for(int i=0;i<28;i++) {
try {
switch (i) {
case 0:
theLump = readLumpNum(i);
BSPObject.Textures = Texture.createLump(theLump, version);
break;
case 1:
theLump = readLumpNum(i);
BSPObject.Planes = Plane.createLump(theLump, version);
break;
case 3:
theLump = readLumpNum(i);
BSPObject.Faces = Face.createLump(theLump, version);
break;
case 4:
theLump = readLumpNum(i);
BSPObject.Vertices = Vertex.createLump(theLump, version);
break;
case 11:
theLump = readLumpNum(i);
BSPObject.BrushSides = BrushSide.createLump(theLump, version);
break;
case 12:
theLump = readLumpNum(i);
BSPObject.Brushes = Brush.createLump(theLump, version);
break;
case 13:
theLump = readLumpNum(i);
BSPObject.Models = Model.createLump(theLump, version);
break;
case 14:
theLump = readLumpNum(i);
BSPObject.Entities = Entity.createLump(theLump);
break;
//case 24:
// theLump = readLumpNum(i);
// BSPObject.StaticProps = StaticProp.createLump(theLump);
// break;
}
}
catch
{
dumpLump(theLump);
}
}
break;
case mapType.TYPE_FAKK:
DecompilerThread.OnMessage(this, "Heavy Metal FAKK² BSP");
for(int i=0;i<20;i++) {
try {
switch (i) {
case 0:
theLump = readLumpNum(i);
BSPObject.Textures = Texture.createLump(theLump, version);
break;
case 1:
theLump = readLumpNum(i);
BSPObject.Planes = Plane.createLump(theLump, version);
break;
case 10:
theLump = readLumpNum(i);
BSPObject.BrushSides = BrushSide.createLump(theLump, version);
break;
case 11:
theLump = readLumpNum(i);
BSPObject.Brushes = Brush.createLump(theLump, version);
break;
case 13:
theLump = readLumpNum(i);
BSPObject.Models = Model.createLump(theLump, version);
break;
case 14:
theLump = readLumpNum(i);
BSPObject.Entities = Entity.createLump(theLump);
break;
}
}
catch
{
dumpLump(theLump);
}
}
break;
case mapType.TYPE_RAVEN:
case mapType.TYPE_QUAKE3:
DecompilerThread.OnMessage(this, "BSP v46 (id Tech 3)");
for(int i=0;i<18;i++) {
try {
switch (i) {
case 0:
theLump = readLumpNum(i);
BSPObject.Entities = Entity.createLump(theLump);
break;
case 1:
theLump = readLumpNum(i);
BSPObject.Textures = Texture.createLump(theLump, version);
break;
case 2:
theLump = readLumpNum(i);
BSPObject.Planes = Plane.createLump(theLump, version);
break;
case 7:
theLump = readLumpNum(i);
BSPObject.Models = Model.createLump(theLump, version);
break;
case 8:
theLump = readLumpNum(i);
BSPObject.Brushes = Brush.createLump(theLump, version);
break;
case 9:
theLump = readLumpNum(i);
BSPObject.BrushSides = BrushSide.createLump(theLump, version);
break;
case 10:
theLump = readLumpNum(i);
BSPObject.Vertices = Vertex.createLump(theLump, version);
break;
case 13:
theLump = readLumpNum(i);
BSPObject.Faces = Face.createLump(theLump, version);
break;
}
}
catch
{
dumpLump(theLump);
}
}
break;
case mapType.TYPE_COD:
DecompilerThread.OnMessage(this, "BSP v59 (Call of Duty)");
for(int i=0;i<33;i++) {
try {
switch (i) {
case 0:
theLump = readLumpNum(i);
BSPObject.Textures = Texture.createLump(theLump, version);
break;
case 2:
theLump = readLumpNum(i);
BSPObject.Planes = Plane.createLump(theLump, version);
break;
case 3:
theLump = readLumpNum(i);
BSPObject.BrushSides = BrushSide.createLump(theLump, version);
break;
case 4:
theLump = readLumpNum(i);
BSPObject.Brushes = Brush.createLump(theLump, version);
break;
case 27:
theLump = readLumpNum(i);
BSPObject.Models = Model.createLump(theLump, version);
break;
case 29:
theLump = readLumpNum(i);
BSPObject.Entities = Entity.createLump(theLump);
break;
}
}
catch
{
dumpLump(theLump);
}
}
break;
case mapType.TYPE_COD2:
DecompilerThread.OnMessage(this, "Call of Duty 2 BSP");
for(int i=0;i<40;i++) {
try {
switch (i) {
case 0:
theLump = readLumpNum(i);
BSPObject.Textures = Texture.createLump(theLump, version);
break;
case 4:
theLump = readLumpNum(i);
BSPObject.Planes = Plane.createLump(theLump, version);
break;
case 5:
theLump = readLumpNum(i);
BSPObject.BrushSides = BrushSide.createLump(theLump, version);
break;
case 6:
theLump = readLumpNum(i);
BSPObject.Brushes = Brush.createLump(theLump, version);
break;
case 35:
theLump = readLumpNum(i);
BSPObject.Models = Model.createLump(theLump, version);
break;
case 37:
theLump = readLumpNum(i);
BSPObject.Entities = Entity.createLump(theLump);
break;
}
}
catch
{
dumpLump(theLump);
}
}
break;
case mapType.TYPE_COD4:
DecompilerThread.OnMessage(this, "Call of Duty 4 BSP");
for(int i=0;i<55;i++) {
try {
switch (i) {
case 0:
theLump = readLumpNum(i);
BSPObject.Textures = Texture.createLump(theLump, version);
break;
case 4:
theLump = readLumpNum(i);
BSPObject.Planes = Plane.createLump(theLump, version);
break;
case 5:
theLump = readLumpNum(i);
BSPObject.BrushSides = BrushSide.createLump(theLump, version);
break;
case 8:
theLump = readLumpNum(i);
BSPObject.Brushes = Brush.createLump(theLump, version);
break;
case 37:
theLump = readLumpNum(i);
BSPObject.Models = Model.createLump(theLump, version);
break;
case 39:
theLump = readLumpNum(i);
BSPObject.Entities = Entity.createLump(theLump);
break;
}
}
catch
{
dumpLump(theLump);
}
}
break;
case mapType.TYPE_DOOM:
case mapType.TYPE_HEXEN:
DecompilerThread.OnMessage(this, "WAD file found");
stream.Seek(4, SeekOrigin.Begin);
int numLumps = br.ReadInt32();
for(int i=0;i<numLumps;i++) {
string name = getLumpName(i);
if((name.Length == 5 && name[0] == 'M' && name[1] == 'A' && name[2] == 'P' && name[3] >= '0' && name[3] <= '9' && name[4] >= '0' && name[4] <= '9')
|| ((name.Length == 4 && name[0] == 'E' && name[1] >= '0' && name[1] <= '9' && name[2] == 'M' && name[3] >= '0' && name[3] <= '9'))) {
if(getLumpName(i+11) == "BEHAVIOR") {
version = mapType.TYPE_HEXEN;
}
DecompilerThread.OnMessage(this, "Map: " + name);
DoomMap currentMap = new DoomMap(BSPFile.FullName, name, version);
int[] headerInfo = getLumpInfo(i);
if (headerInfo[1] > 0 && Settings.extractZip) {
Console.Write("Extracting Map Header ");
writeLump(name+".txt", readLumpNum(i));
}
currentMap.Things = DThing.createLump(readLumpNum(i+1), version);
currentMap.Linedefs = DLinedef.createLump(readLumpNum(i+2), version);
currentMap.Sidedefs = DSidedef.createLump(readLumpNum(i+3));
currentMap.Vertices = Vertex.createLump(readLumpNum(i+4), version);
currentMap.Segments = DSegment.createLump(readLumpNum(i+5));
currentMap.SubSectors = Edge.createLump(readLumpNum(i+6), version);
currentMap.Nodes = DNode.createLump(readLumpNum(i+7));
currentMap.Sectors = DSector.createLump(readLumpNum(i+8));
doomMaps.Add(currentMap);
currentMap.printBSPReport();
}
}
break;
default:
DecompilerThread.OnMessage(this, "Tried to populate structures for a format not implemented yet!");
break;
}
BSPObject.printBSPReport();
}
catch (System.IO.IOException) {
DecompilerThread.OnMessage(this, "Unable to access BSP file! Is it open in another program?");
}
br.Close();
}
public SourceStaticProp(LumpObject data, mapType type, int version):base(data.Data) {
new SourceStaticProp(data.Data, type, version);
}
// CONSTRUCTORS
// Takes a String in and assumes it is a path. That path is the path to the file
// that is the BSP and its name minus the .BSP extension is assumed to be the folder.
// See comments below for clarification. Case does not matter on the extension, so it
// could be .BSP, .bsp, etc.
public BSPReader(string path, mapType readAs) : this(new FileInfo(path), readAs) {
}
