private void LoadLumpAt(string path, int index)
{
string filename = Path.GetFileName(path);
BinaryReader br;
if (filename.Length > 12)
{
//trim the filename
filename = filename.Remove(12);
}
br = new BinaryReader(File.Open(path, FileMode.Open));
int size = (int)br.BaseStream.Length;
byte[] data = br.ReadBytes((int)br.BaseStream.Length);
HOGLump newLump = new HOGLump(filename, size, -1);
newLump.Data = data;
newLump.Type = HOGLump.IdentifyLump(newLump.Name, newLump.Data);
//datafile.AddLump(newLump);
ListViewItem lumpElement = new ListViewItem(newLump.Name);
lumpElement.SubItems.Add(newLump.Size.ToString());
lumpElement.SubItems.Add(newLump.Type.ToString());
if (index != -1)
{
listView1.Items.Insert(index, lumpElement);
datafile.AddLumpAt(newLump, index);
}
else
{
listView1.Items.Add(lumpElement);
datafile.AddLump(newLump);
}
}
public void TestCreateNewHog()
{
var hogFile = new HOGFile();
Assert.AreEqual(0, hogFile.NumLumps);
var filename = "test.rdl";
//hogFile.AddFile(filename, TestUtils.GetResourceStream(filename));
HOGLump lump = new HOGLump(filename, TestUtils.GetArrayFromResourceStream(filename));
hogFile.Lumps.Add(lump);
Assert.AreEqual(1, hogFile.NumLumps);
var memoryStream = new MemoryStream();
hogFile.Write(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
hogFile.Read(memoryStream);
Assert.AreEqual(1, hogFile.NumLumps);
//TODO: api change
//Assert.IsNotNull(hogFile.GetLumpHeader(filename));
//Assert.That(hogFile.GetLumpData(filename), Is.EqualTo(TestUtils.GetArrayFromResourceStream(filename)));
}
/// <summary>
/// Adds a lump to the HOG file at a given index.
/// </summary>
/// <param name="lump">The lump to add.</param>
/// <param name="index">The index to add at.</param>
public void AddLumpAt(HOGLump lump, int index)
{
lock (lumpLock)
{
lumps.Insert(index, lump);
//For now, invalidate the lump map when adding a lump at a given location
//since otherwise the old indicies would be messed up.
lock (lumpNameLock)
lumpNameMap = null;
}
}
/// <summary>
/// Adds a lump to the HOG file.
/// </summary>
/// <param name="lump">The lump to add.</param>
public void AddLump(HOGLump lump)
{
lock (lumpLock)
{
lumps.Add(lump);
if (lumpNameMap != null && !lumpNameMap.ContainsKey(lump.Name))
{
lock (lumpNameLock)
lumpNameMap[lump.Name] = lumps.Count - 1;
}
}
}
/// <summary>
/// Replaces the lump in a HOG file. The replacement applies
/// if another lump with the same file name is already present,
/// and otherwise the lump is simply added.
/// </summary>
/// <param name="lump">The lump to add.</param>
public void ReplaceLump(HOGLump lump)
{
lock (lumpLock)
lock (lumpNameLock)
{
int lumpNum;
do
{
lumpNum = GetLumpNum(lump.Name);
if (lumpNum >= 0)
{
lumps.RemoveAt(lumpNum);
lumpNameMap = null;
}
} while (lumpNum >= 0);
AddLump(lump);
}
}
public void TestAddLump()
{
var hogFile = new HOGFile(TestUtils.GetResourceStream("standard.hog"));
// Method 1 - set up lump manually
var file1Data = TestUtils.GetArrayFromResourceStream("test.rdl");
var hogLump = new HOGLump("test.rdl", file1Data.Length, 0)
{
Data = file1Data
};
hogFile.Lumps.Add(hogLump);
Assert.AreEqual(4, hogFile.NumLumps);
//Assert.AreEqual(3, hogFile.GetLumpNum("test.rdl")); //api change
// Method 2 - use constructor
var file2Data = TestUtils.GetArrayFromResourceStream("test.rl2");
hogLump = new HOGLump("test2.rl2", file2Data);
hogFile.Lumps.Add(hogLump);
Assert.AreEqual(5, hogFile.NumLumps);
//Assert.AreEqual(4, hogFile.GetLumpNum("test2.rl2"));
// Make sure it writes correctly
var memoryStream = new MemoryStream();
hogFile.Write(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
hogFile.Read(memoryStream);
Assert.AreEqual(5, hogFile.NumLumps);
//Assert.AreEqual(3, hogFile.GetLumpNum("test.rdl"));
Assert.That(hogFile.GetLumpData(3), Is.EqualTo(file1Data));
//Assert.AreEqual(4, hogFile.GetLumpNum("test2.rl2"));
Assert.That(hogFile.GetLumpData(4), Is.EqualTo(file2Data));
}
/// <summary>
/// Reads the data of a HOG file from a stream.
/// </summary>
/// <param name="stream">The stream to read the HOG file from.</param>
public void Read(Stream stream)
{
lock (hogFileLock)
lock (lumpLock)
lock (lumpNameLock)
{
BinaryReader br = new BinaryReader(stream);
fileStream = br;
lumps.Clear();
char[] header = new char[3];
header[0] = (char)br.ReadByte();
header[1] = (char)br.ReadByte();
header[2] = (char)br.ReadByte();
var headerString = new string(header);
switch (headerString)
{
case "DHF":
Format = HOGFormat.Standard;
break;
case "D2X":
Format = HOGFormat.D2X_XL;
break;
default:
throw new InvalidDataException($"Unrecognized HOG header \"{headerString}\"");
}
try
{
while (true)
{
char[] filenamedata = new char[13];
bool hashitnull = false;
for (int x = 0; x < 13; x++)
{
char c = (char)br.ReadByte();
if (c == 0)
{
hashitnull = true;
}
if (!hashitnull)
{
filenamedata[x] = c;
}
}
string filename = new string(filenamedata);
filename = filename.Trim(' ', '\0');
int filesize = br.ReadInt32();
if (Format == HOGFormat.D2X_XL && filesize < 0)
{
// D2X-XL format encodes "extended" lump headers with negative file sizes
filesize = -filesize;
string longFilename = Encoding.ASCII.GetString(br.ReadBytes(256));
if (longFilename.Contains("\0"))
{
longFilename = longFilename.Remove(longFilename.IndexOf('\0'));
}
longFilename = longFilename.Trim(' ');
// No real reason to use short filename in this instance; just replace it
filename = longFilename;
}
int offset = (int)br.BaseStream.Position;
br.BaseStream.Seek(filesize, SeekOrigin.Current); //I hate hog files. Wads are cooler..
HOGLump lump = new HOGLump(filename, filesize, offset);
lumps.Add(lump);
}
}
catch (EndOfStreamException)
{
//we got all the files
//heh
//i love hog
byte[] data;
for (int i = 0; i < NumLumps; i++)
{
data = GetLumpData(i);
lumps[i].Type = HOGLump.IdentifyLump(lumps[i].Name, data);
}
}
}
}
