static void Main(string[] args)
{
var synthesizer = new Synthesizer(MusDecoder.SampleRate, 2, MusDecoder.BufferLength, 1);
var bank = new PatchBank("TimGM6mb.sf2");
synthesizer.LoadBank(bank);
var buffer = new byte[synthesizer.RawBufferSize];
var format = new WaveFormat(MusDecoder.SampleRate, 16, 2);
using (var wad = new Wad("DOOM.WAD"))
using (var writer = new WaveFileWriter("out.wav", format))
{
var md = new MusDecoder(wad.ReadLump("D_E1M1"), true);
var sampleCount = 0;
while (true)
{
md.FillBuffer(synthesizer, buffer);
writer.Write(buffer, 0, buffer.Length);
sampleCount += MusDecoder.BufferLength;
if (sampleCount > 240 * MusDecoder.SampleRate)
{
break;
}
}
}
}
public void TestFileStreamRebuildWad()
{
WadBuilder wadBuilder = new WadBuilder();
// Build entries
foreach (WadEntry entry in this._originalWad.Entries.Values)
{
WadEntryBuilder entryBuilder = new WadEntryBuilder(entry.ChecksumType);
Stream entryDecompressedStream = entry.GetDataHandle().GetDecompressedStream();
string entryFileName = "temp/" + entry.XXHash + "." + Utilities.GetExtension(Utilities.GetExtensionType(entryDecompressedStream));
// Extract entry data to temporary file
using (FileStream writeEntryFileStream = File.OpenWrite(entryFileName))
{
entry.GetDataHandle().GetDecompressedStream().CopyTo(writeEntryFileStream);
}
entryBuilder
.WithPathXXHash(entry.XXHash)
.WithFileDataStream(entryFileName);
wadBuilder.WithEntry(entryBuilder);
}
MemoryStream rebuiltWadStream = new MemoryStream();
Assert.DoesNotThrow(delegate
{
wadBuilder.Build(rebuiltWadStream, true);
}, "Failed to build WAD using files");
rebuiltWadStream.Seek(0, SeekOrigin.Begin);
this._fileStreamWad = Wad.Mount(rebuiltWadStream, true);
}
public void LoadE1M1()
{
using (var wad = new Wad(WadPath.Doom1))
{
var map = wad.GetLumpNumber("E1M1");
var flats = new FlatLookup(wad, false);
var sectors = Sector.FromWad(wad, map + 8, flats);
Assert.AreEqual(88, sectors.Length);
Assert.AreEqual(-80, sectors[0].FloorHeight.ToDouble(), delta);
Assert.AreEqual(216, sectors[0].CeilingHeight.ToDouble(), delta);
Assert.AreEqual("NUKAGE3", flats[sectors[0].FloorFlat].Name);
Assert.AreEqual("F_SKY1", flats[sectors[0].CeilingFlat].Name);
Assert.AreEqual(255, sectors[0].LightLevel);
Assert.AreEqual((SectorSpecial)7, sectors[0].Special);
Assert.AreEqual(0, sectors[0].Tag);
Assert.AreEqual(0, sectors[42].FloorHeight.ToDouble(), delta);
Assert.AreEqual(264, sectors[42].CeilingHeight.ToDouble(), delta);
Assert.AreEqual("FLOOR7_1", flats[sectors[42].FloorFlat].Name);
Assert.AreEqual("F_SKY1", flats[sectors[42].CeilingFlat].Name);
Assert.AreEqual(255, sectors[42].LightLevel);
Assert.AreEqual((SectorSpecial)0, sectors[42].Special);
Assert.AreEqual(0, sectors[42].Tag);
Assert.AreEqual(104, sectors[87].FloorHeight.ToDouble(), delta);
Assert.AreEqual(184, sectors[87].CeilingHeight.ToDouble(), delta);
Assert.AreEqual("FLOOR4_8", flats[sectors[87].FloorFlat].Name);
Assert.AreEqual("FLOOR6_2", flats[sectors[87].CeilingFlat].Name);
Assert.AreEqual(128, sectors[87].LightLevel);
Assert.AreEqual((SectorSpecial)9, sectors[87].Special);
Assert.AreEqual(2, sectors[87].Tag);
}
}
public MenuRenderer(Wad wad, DrawScreen screen)
{
this.wad = wad;
this.screen = screen;
patches = new Dictionary <string, Patch>();
}
public void LoadMap01()
{
using (var wad = new Wad(WadPath.Doom2))
{
var map = wad.GetLumpNumber("MAP01");
var flats = new FlatLookup(wad, false);
var sectors = Sector.FromWad(wad, map + 8, flats);
Assert.AreEqual(59, sectors.Length);
Assert.AreEqual(8, sectors[0].FloorHeight.ToDouble(), delta);
Assert.AreEqual(264, sectors[0].CeilingHeight.ToDouble(), delta);
Assert.AreEqual("FLOOR0_1", flats[sectors[0].FloorFlat].Name);
Assert.AreEqual("FLOOR4_1", flats[sectors[0].CeilingFlat].Name);
Assert.AreEqual(128, sectors[0].LightLevel);
Assert.AreEqual(SectorSpecial.Normal, sectors[0].Special);
Assert.AreEqual(0, sectors[0].Tag);
Assert.AreEqual(56, sectors[57].FloorHeight.ToDouble(), delta);
Assert.AreEqual(184, sectors[57].CeilingHeight.ToDouble(), delta);
Assert.AreEqual("FLOOR3_3", flats[sectors[57].FloorFlat].Name);
Assert.AreEqual("CEIL3_3", flats[sectors[57].CeilingFlat].Name);
Assert.AreEqual(144, sectors[57].LightLevel);
Assert.AreEqual((SectorSpecial)9, sectors[57].Special);
Assert.AreEqual(0, sectors[57].Tag);
Assert.AreEqual(56, sectors[58].FloorHeight.ToDouble(), delta);
Assert.AreEqual(56, sectors[58].CeilingHeight.ToDouble(), delta);
Assert.AreEqual("FLOOR3_3", flats[sectors[58].FloorFlat].Name);
Assert.AreEqual("FLAT20", flats[sectors[58].CeilingFlat].Name);
Assert.AreEqual(144, sectors[58].LightLevel);
Assert.AreEqual(SectorSpecial.Normal, sectors[58].Special);
Assert.AreEqual(6, sectors[58].Tag);
}
}
public OpeningSequenceRenderer(Wad wad, DrawScreen screen, SfmlRenderer parent)
{
this.screen = screen;
this.parent = parent;
cache = new PatchCache(wad);
}
public void LoadMap01()
{
using (var wad = new Wad(WadPath.Doom2))
{
var map = wad.GetLumpNumber("MAP01");
var things = MapThing.FromWad(wad, map + 1);
Assert.AreEqual(69, things.Length);
Assert.AreEqual(-96, things[0].X.ToDouble(), delta);
Assert.AreEqual(784, things[0].Y.ToDouble(), delta);
Assert.AreEqual(90, things[0].Angle.ToDegree(), delta);
Assert.AreEqual(1, things[0].Type);
Assert.AreEqual(7, (int)things[0].Flags);
Assert.AreEqual(-288, things[57].X.ToDouble(), delta);
Assert.AreEqual(976, things[57].Y.ToDouble(), delta);
Assert.AreEqual(270, things[57].Angle.ToDegree(), delta);
Assert.AreEqual(2006, things[57].Type);
Assert.AreEqual(23, (int)things[57].Flags);
Assert.AreEqual(-480, things[68].X.ToDouble(), delta);
Assert.AreEqual(848, things[68].Y.ToDouble(), delta);
Assert.AreEqual(0, things[68].Angle.ToDegree(), delta);
Assert.AreEqual(2005, things[68].Type);
Assert.AreEqual(7, (int)things[68].Flags);
}
}
public MenuRenderer(Wad wad, DrawScreen screen)
{
this.wad = wad;
this.screen = screen;
cache = new PatchCache(wad);
}
internal static async Task ExtractWad(Wad wad)
{
foreach (var entry in wad.Entries)
{
if (!Converter.HashTables["game"].ContainsKey(entry.Key))
{
continue;
}
var path = Converter.HashTables["game"][entry.Key].ToLower().Replace('/', '\\');
if (!Converter.Config.ExtractFormats.Contains(Path.GetExtension(path)))
{
continue;
}
if (path.EndsWith(".bin") && !path.Contains("animations"))
{
continue;
}
var folderPath = Path.GetDirectoryName(path);
if (!Directory.Exists(folderPath))
{
Directory.CreateDirectory(folderPath);
}
var outputFile = File.Create(path);
await entry.Value.GetDataHandle().GetDecompressedStream().CopyToAsync(outputFile);
await outputFile.DisposeAsync();
}
}
public void LoadE1M1()
{
using (var wad = new Wad(WadPath.Doom1))
{
var flats = new FlatLookup(wad, true);
var textures = new TextureLookup(wad, true);
var map = wad.GetLumpNumber("E1M1");
var vertices = Vertex.FromWad(wad, map + 4);
var sectors = Sector.FromWad(wad, map + 8, flats);
var sides = SideDef.FromWad(wad, map + 3, textures, sectors);
var lines = LineDef.FromWad(wad, map + 2, vertices, sides);
var segs = Seg.FromWad(wad, map + 5, vertices, lines);
var subsectors = Subsector.FromWad(wad, map + 6, segs);
Assert.AreEqual(239, subsectors.Length);
Assert.AreEqual(8, subsectors[0].SegCount);
for (var i = 0; i < 8; i++)
{
Assert.IsTrue(segs[subsectors[0].FirstSeg + i] == segs[0 + i]);
}
Assert.AreEqual(1, subsectors[54].SegCount);
for (var i = 0; i < 1; i++)
{
Assert.IsTrue(segs[subsectors[54].FirstSeg + i] == segs[181 + i]);
}
Assert.AreEqual(2, subsectors[238].SegCount);
for (var i = 0; i < 2; i++)
{
Assert.IsTrue(segs[subsectors[238].FirstSeg + i] == segs[745 + i]);
}
}
}
public void LoadMap01()
{
using (var wad = new Wad(WadPath.Doom2))
{
var flats = new FlatLookup(wad, true);
var textures = new TextureLookup(wad, true);
var map = wad.GetLumpNumber("MAP01");
var vertices = Vertex.FromWad(wad, map + 4);
var sectors = Sector.FromWad(wad, map + 8, flats);
var sides = SideDef.FromWad(wad, map + 3, textures, sectors);
var lines = LineDef.FromWad(wad, map + 2, vertices, sides);
var segs = Seg.FromWad(wad, map + 5, vertices, lines);
var subsectors = Subsector.FromWad(wad, map + 6, segs);
Assert.AreEqual(194, subsectors.Length);
Assert.AreEqual(4, subsectors[0].SegCount);
for (var i = 0; i < 4; i++)
{
Assert.IsTrue(segs[subsectors[0].FirstSeg + i] == segs[i]);
}
Assert.AreEqual(4, subsectors[57].SegCount);
for (var i = 0; i < 4; i++)
{
Assert.IsTrue(segs[subsectors[57].FirstSeg + i] == segs[179 + i]);
}
Assert.AreEqual(4, subsectors[193].SegCount);
for (var i = 0; i < 4; i++)
{
Assert.IsTrue(segs[subsectors[193].FirstSeg + i] == segs[597 + i]);
}
}
}
public void AddLumpAtPositionTest()
{
var wad = new Wad("dummy", 1, "filename.wad");
for (int i = 0; i < 5; i++)
{
Lump lump = new Lump();
lump.Name = $"NEWLUMP{i}";
lump.Position = i;
wad.AddLump(lump);
}
Assert.AreEqual(5, wad.LumpCount);
Lump insertedLump = new Lump();
insertedLump.Position = 100;
insertedLump.Name = "INSERED_LUMP";
wad.AddLumpAtPosition(insertedLump, 3);
Assert.AreEqual(6, wad.LumpCount);
Assert.AreEqual(insertedLump, wad.GetLumpAtPosition(3));
Assert.AreEqual(3, insertedLump.Position);
Lump lastLump = wad.GetLumpAtPosition(wad.LumpCount - 1);
Assert.AreEqual(5, lastLump.Position);
Assert.AreEqual("NEWLUMP4", lastLump.Name);
}
private void OnCollisionEnter2D(Collision2D collision)
{
if (collision.gameObject.CompareTag("Wad"))
{
Wad wad = collision.gameObject.GetComponent <Wad>();
wad.Collect(EntityFactory.Instance.GetPlayer());
vanBody.AddForceAtPosition(force, collision.contacts[0].point);
van.ArtificalMaxRPM = artificalMaxRPM;
van.Gas(gasDuration);
}
else if (collision.gameObject.CompareTag("Player"))
{
Destroy(collision.gameObject);
van.ArtificalMaxRPM = Mathf.Infinity;
van.ReadyWheelsForDrive();
van.GasUntil(targetRPM);
van.TargetSpeed = motorSpeed;
if (EndSceneSequenceManager.Instance.UseDriveSequence)
{
TransformTracker.Instance.FixedTarget = null;
TransformTracker.Instance.Target = vanBody.transform;
TransformTracker.Instance.HorizontalTrackingSpeed = horizontalTrackingSpeed;
}
}
}
public void LoadE1M1()
{
using (var wad = new Wad(WadPath.Doom1))
{
var map = wad.GetLumpNumber("E1M1");
var things = MapThing.FromWad(wad, map + 1);
Assert.AreEqual(143, things.Length);
Assert.AreEqual(1056, things[0].X.ToDouble(), delta);
Assert.AreEqual(-3616, things[0].Y.ToDouble(), delta);
Assert.AreEqual(90, things[0].Angle.ToDegree(), delta);
Assert.AreEqual(1, things[0].Type);
Assert.AreEqual(7, (int)things[0].Flags);
Assert.AreEqual(3072, things[57].X.ToDouble(), delta);
Assert.AreEqual(-4832, things[57].Y.ToDouble(), delta);
Assert.AreEqual(180, things[57].Angle.ToDegree(), delta);
Assert.AreEqual(2015, things[57].Type);
Assert.AreEqual(7, (int)things[57].Flags);
Assert.AreEqual(736, things[142].X.ToDouble(), delta);
Assert.AreEqual(-2976, things[142].Y.ToDouble(), delta);
Assert.AreEqual(90, things[142].Angle.ToDegree(), delta);
Assert.AreEqual(2001, things[142].Type);
Assert.AreEqual(23, (int)things[142].Flags);
}
}
public void ConstructorMinimalParametersTests()
{
var wad = new Wad(@"TestResources\doom1.wad");
Assert.AreEqual(4274218, wad.WadSize);
Assert.AreEqual(@"TestResources\doom1.wad", wad.Path);
Assert.AreEqual("doom1.wad", wad.Filename);
}
public IntermissionRenderer(Wad wad, DrawScreen screen)
{
this.screen = screen;
patches = new Patches(wad);
scale = screen.Width / 320;
}
public void Initialize()
{
wad = Wad.FromFile("DOOM.WAD");
mapLoader = new MapLoader(wad);
var map = mapLoader.LoadByName("E1M1");
renderer.InitializeResources(map);
}
public void ConstructorFullParametersTests()
{
var wad = new Wad("dummy", 10, "filename.wad");
Assert.AreEqual(10, wad.WadSize);
Assert.AreEqual("dummy", wad.Path);
Assert.AreEqual("filename.wad", wad.Filename);
Assert.AreEqual("filename.wad", wad.ToString());
}
public SfmlSound(Config config, Wad wad)
{
try
{
Console.Write("Initialize sound: ");
this.config = config;
config.audio_soundvolume = Math.Clamp(config.audio_soundvolume, 0, MaxVolume);
buffers = new SoundBuffer[DoomInfo.SfxNames.Length];
amplitudes = new float[DoomInfo.SfxNames.Length];
for (var i = 0; i < DoomInfo.SfxNames.Length; i++)
{
var name = "DS" + DoomInfo.SfxNames[i];
var lump = wad.GetLumpNumber(name);
if (lump == -1)
{
continue;
}
int sampleRate;
int sampleCount;
var samples = GetSamples(wad, name, out sampleRate, out sampleCount);
if (samples != null)
{
buffers[i] = new SoundBuffer(samples, 1, (uint)sampleRate);
amplitudes[i] = GetAmplitude(samples, sampleRate, sampleCount);
}
}
channels = new Sound[channelCount];
infos = new ChannelInfo[channelCount];
for (var i = 0; i < channels.Length; i++)
{
channels[i] = new Sound();
infos[i] = new ChannelInfo();
}
uiChannel = new Sound();
uiReserved = Sfx.NONE;
masterVolumeDecay = (float)config.audio_soundvolume / MaxVolume;
lastUpdate = DateTime.MinValue;
Console.WriteLine("OK");
}
catch (Exception e)
{
Console.WriteLine("Failed");
Dispose();
ExceptionDispatchInfo.Throw(e);
}
}
void FixedUpdate()
{
if (move == true)
{
Vector3 currentVelocity = rigidBody.velocity;
currentVelocity.x = -transform.right.x * moveSpeed;
rigidBody.velocity = currentVelocity;
if (Mathf.Abs(currentVelocity.y) < 0.1f)
{
Collider2D groundCollider = Physics2D.OverlapCircle(groundSensor.position, 2.0f, LayerMask.GetMask("Ground"));
if (groundCollider == null)
{
transform.rotation = transform.rotation * Quaternion.AngleAxis(180.0f, Vector3.up);
}
}
Collider2D wallCollider = Physics2D.OverlapCircle(wallSensor.position, 2.0f, LayerMask.GetMask("Ground"));
if (wallCollider)
{
transform.rotation = transform.rotation * Quaternion.AngleAxis(180.0f, Vector3.up);
}
if (damageCollider)
{
ContactFilter2D filter = new ContactFilter2D();
filter.ClearLayerMask();
filter.SetLayerMask(LayerMask.GetMask("Player"));
Collider2D[] results = new Collider2D[8];
int nCollision = Physics2D.OverlapCollider(damageCollider, filter, results);
if (nCollision > 0)
{
foreach (var collider in results)
{
if (collider)
{
Wad wad = collider.GetComponent <Wad>();
if (wad)
{
Vector3 hitDirection = (wad.transform.position - transform.position).normalized;
hitDirection.y = 1.0f;
wad.DamagePlayer(1);
}
}
}
}
}
}
}
public void TestReadOriginalWad()
{
// Test whether we can read the file
Assert.DoesNotThrow(delegate
{
this._originalWad = Wad.Mount(Path.Combine(WAD_DIR, this._wadName), true);
},
"Failed to read the file");
Assert.Pass();
}
public void LumpNumberDoom2()
{
using (var wad = new Wad(WadPath.Doom2))
{
Assert.AreEqual(0, wad.GetLumpNumber("PLAYPAL"));
Assert.AreEqual(1, wad.GetLumpNumber("COLORMAP"));
Assert.AreEqual(6, wad.GetLumpNumber("MAP01"));
Assert.AreEqual(2918, wad.GetLumpNumber("F_END"));
Assert.AreEqual(2919, wad.LumpInfos.Count);
}
}
public void LumpNumberDoom1()
{
using (var wad = new Wad(WadPath.Doom1))
{
Assert.AreEqual(0, wad.GetLumpNumber("PLAYPAL"));
Assert.AreEqual(1, wad.GetLumpNumber("COLORMAP"));
Assert.AreEqual(7, wad.GetLumpNumber("E1M1"));
Assert.AreEqual(2305, wad.GetLumpNumber("F_END"));
Assert.AreEqual(2306, wad.LumpInfos.Count);
}
}
/// <summary>
/// Reads an archive from the path provided.
/// </summary>
/// <param name="path">The path to read from.</param>
/// <returns>The archive, if it can be read.</returns>
public static Optional <IArchive> ReadFile(string path)
{
if (path.EndsWith(".wad", StringComparison.OrdinalIgnoreCase))
{
return(Wad.FromArchive(path));
}
// Note that by not searching for PK3 only, we indirectly support
// reading anything that is a zip archive.
return(PK3.FromArchive(path));
}
public FinaleRenderer(CommonResource resource, DrawScreen screen)
{
wad = resource.Wad;
flats = resource.Flats;
sprites = resource.Sprites;
this.screen = screen;
scale = screen.Width / 320;
cache = new PatchCache(wad);
}
public FinaleRenderer(GameContent content, DrawScreen screen)
{
wad = content.Wad;
flats = content.Flats;
sprites = content.Sprites;
this.screen = screen;
scale = screen.Width / 320;
cache = new PatchCache(wad);
}
public Patches(Wad wad)
{
Background = Patch.FromWad(wad, "STBAR");
TallNumbers = new Patch[10];
ShortNumbers = new Patch[10];
for (var i = 0; i < 10; i++)
{
TallNumbers[i] = Patch.FromWad(wad, "STTNUM" + i);
ShortNumbers[i] = Patch.FromWad(wad, "STYSNUM" + i);
}
TallMinus = Patch.FromWad(wad, "STTMINUS");
TallPercent = Patch.FromWad(wad, "STTPRCNT");
Keys = new Patch[(int)CardType.Count];
for (var i = 0; i < Keys.Length; i++)
{
Keys[i] = Patch.FromWad(wad, "STKEYS" + i);
}
ArmsBackground = Patch.FromWad(wad, "STARMS");
Arms = new Patch[6][];
for (var i = 0; i < 6; i++)
{
var num = i + 2;
Arms[i] = new Patch[2];
Arms[i][0] = Patch.FromWad(wad, "STGNUM" + num);
Arms[i][1] = ShortNumbers[num];
}
FaceBackground = new Patch[Player.MaxPlayerCount];
for (var i = 0; i < FaceBackground.Length; i++)
{
FaceBackground[i] = Patch.FromWad(wad, "STFB" + i);
}
Faces = new Patch[StatusBar.Face.FaceCount];
var faceCount = 0;
for (var i = 0; i < StatusBar.Face.PainFaceCount; i++)
{
for (var j = 0; j < StatusBar.Face.StraightFaceCount; j++)
{
Faces[faceCount++] = Patch.FromWad(wad, "STFST" + i + j);
}
Faces[faceCount++] = Patch.FromWad(wad, "STFTR" + i + "0");
Faces[faceCount++] = Patch.FromWad(wad, "STFTL" + i + "0");
Faces[faceCount++] = Patch.FromWad(wad, "STFOUCH" + i);
Faces[faceCount++] = Patch.FromWad(wad, "STFEVL" + i);
Faces[faceCount++] = Patch.FromWad(wad, "STFKILL" + i);
}
Faces[faceCount++] = Patch.FromWad(wad, "STFGOD0");
Faces[faceCount++] = Patch.FromWad(wad, "STFDEAD0");
}
public static async Task StartConversion(MainWindowViewModel viewModel, LoggingWindowViewModel loggingViewModel)
{
loggingViewModel.AddLine("Reading config.json");
var fileStream = File.OpenRead("config.json");
Config = await JsonSerializer.DeserializeAsync <Config>(fileStream);
await fileStream.DisposeAsync();
Config.CalculateScale();
if (viewModel.IncludeSkeletons)
{
Config.ExtractFormats.Add(".skl");
}
if (viewModel.IncludeAnimations)
{
Config.ExtractFormats.Add(".anm");
Config.ExtractFormats.Add(".bin");
}
var currentDirectory = Environment.CurrentDirectory;
Directory.SetCurrentDirectory(viewModel.OutPath);
loggingViewModel.AddLine("Cleaning");
if (Directory.Exists("assets"))
{
Directory.Delete("assets", true);
}
if (Directory.Exists("data"))
{
Directory.Delete("data", true);
}
loggingViewModel.AddLine("Reading hashtables");
await Utils.ReadHashTables();
foreach (var path in Directory.EnumerateFiles(@$ "{viewModel.LeaguePath}\Game\DATA\FINAL\Champions", "*.wad.client")
.Where(f => !f.Contains('_') &&
(Config.IncludeOnly.Count == 0 ||
Config.IncludeOnly.Contains(Path.GetFileName(f)))))
{
loggingViewModel.AddLine($"Extracting {path}");
var wad = Wad.Mount(path, true);
await Utils.ExtractWad(wad);
foreach (var entry in wad.Entries.Where(e => HashTables["game"].ContainsKey(e.Key)))
{
var name = HashTables["game"][entry.Key].ToLower().Replace('/', '\\');
if (!name.EndsWith(".bin") || !name.Contains(@"\skins\") || name.Contains("root"))
{
continue;
}
var splitName = name.Split('\\');
var character = splitName[^ 3];
public void LoadMap01()
{
using (var wad = new Wad(WadPath.Doom2))
{
var flats = new DummyFlatLookup(wad);
var textures = new DummyTextureLookup(wad);
var map = wad.GetLumpNumber("MAP01");
var vertices = Vertex.FromWad(wad, map + 4);
var sectors = Sector.FromWad(wad, map + 8, flats);
var sides = SideDef.FromWad(wad, map + 3, textures, sectors);
var lines = LineDef.FromWad(wad, map + 2, vertices, sides);
var segs = Seg.FromWad(wad, map + 5, vertices, lines);
Assert.AreEqual(601, segs.Length);
Assert.IsTrue(segs[0].Vertex1 == vertices[9]);
Assert.IsTrue(segs[0].Vertex2 == vertices[316]);
Assert.AreEqual(ToRadian(-32768), segs[0].Angle.ToRadian(), delta);
Assert.IsTrue(segs[0].LineDef == lines[8]);
Assert.IsTrue((segs[0].LineDef.Flags & LineFlags.TwoSided) != 0);
Assert.IsTrue(segs[0].FrontSector == segs[0].LineDef.FrontSide.Sector);
Assert.IsTrue(segs[0].BackSector == segs[0].LineDef.BackSide.Sector);
Assert.AreEqual(0, segs[0].Offset.ToDouble(), delta);
Assert.IsTrue(segs[42].Vertex1 == vertices[26]);
Assert.IsTrue(segs[42].Vertex2 == vertices[320]);
Assert.AreEqual(ToRadian(-22209), segs[42].Angle.ToRadian(), delta);
Assert.IsTrue(segs[42].LineDef == lines[33]);
Assert.IsTrue((segs[42].LineDef.Flags & LineFlags.TwoSided) != 0);
Assert.IsTrue(segs[42].FrontSector == segs[42].LineDef.BackSide.Sector);
Assert.IsTrue(segs[42].BackSector == segs[42].LineDef.FrontSide.Sector);
Assert.AreEqual(0, segs[42].Offset.ToDouble(), delta);
Assert.IsTrue(segs[103].Vertex1 == vertices[331]);
Assert.IsTrue(segs[103].Vertex2 == vertices[329]);
Assert.AreEqual(ToRadian(16384), segs[103].Angle.ToRadian(), delta);
Assert.IsTrue(segs[103].LineDef == lines[347]);
Assert.IsTrue((segs[103].LineDef.Flags & LineFlags.TwoSided) == 0);
Assert.IsTrue(segs[103].FrontSector == segs[103].LineDef.FrontSide.Sector);
Assert.IsTrue(segs[103].BackSector == null);
Assert.AreEqual(64, segs[103].Offset.ToDouble(), delta);
Assert.IsTrue(segs[600].Vertex1 == vertices[231]);
Assert.IsTrue(segs[600].Vertex2 == vertices[237]);
Assert.AreEqual(ToRadian(-16384), segs[600].Angle.ToRadian(), delta);
Assert.IsTrue(segs[600].LineDef == lines[271]);
Assert.IsTrue((segs[600].LineDef.Flags & LineFlags.TwoSided) != 0);
Assert.IsTrue(segs[600].FrontSector == segs[600].LineDef.BackSide.Sector);
Assert.IsTrue(segs[600].BackSector == segs[600].LineDef.FrontSide.Sector);
Assert.AreEqual(0, segs[600].Offset.ToDouble(), delta);
}
}
public void LoadE1M1()
{
using (var wad = new Wad(WadPath.Doom1))
{
var flats = new DummyFlatLookup(wad);
var textures = new DummyTextureLookup(wad);
var map = wad.GetLumpNumber("E1M1");
var vertices = Vertex.FromWad(wad, map + 4);
var sectors = Sector.FromWad(wad, map + 8, flats);
var sides = SideDef.FromWad(wad, map + 3, textures, sectors);
var lines = LineDef.FromWad(wad, map + 2, vertices, sides);
var segs = Seg.FromWad(wad, map + 5, vertices, lines);
Assert.AreEqual(747, segs.Length);
Assert.IsTrue(segs[0].Vertex1 == vertices[132]);
Assert.IsTrue(segs[0].Vertex2 == vertices[133]);
Assert.AreEqual(ToRadian(4156), segs[0].Angle.ToRadian(), delta);
Assert.IsTrue(segs[0].LineDef == lines[160]);
Assert.IsTrue((segs[0].LineDef.Flags & LineFlags.TwoSided) != 0);
Assert.IsTrue(segs[0].FrontSector == segs[0].LineDef.FrontSide.Sector);
Assert.IsTrue(segs[0].BackSector == segs[0].LineDef.BackSide.Sector);
Assert.AreEqual(0, segs[0].Offset.ToDouble(), delta);
Assert.IsTrue(segs[28].Vertex1 == vertices[390]);
Assert.IsTrue(segs[28].Vertex2 == vertices[131]);
Assert.AreEqual(ToRadian(-32768), segs[28].Angle.ToRadian(), delta);
Assert.IsTrue(segs[28].LineDef == lines[480]);
Assert.IsTrue((segs[0].LineDef.Flags & LineFlags.TwoSided) != 0);
Assert.IsTrue(segs[28].FrontSector == segs[28].LineDef.BackSide.Sector);
Assert.IsTrue(segs[28].BackSector == segs[28].LineDef.FrontSide.Sector);
Assert.AreEqual(0, segs[28].Offset.ToDouble(), delta);
Assert.IsTrue(segs[744].Vertex1 == vertices[446]);
Assert.IsTrue(segs[744].Vertex2 == vertices[374]);
Assert.AreEqual(ToRadian(-16384), segs[744].Angle.ToRadian(), delta);
Assert.IsTrue(segs[744].LineDef == lines[452]);
Assert.IsTrue((segs[744].LineDef.Flags & LineFlags.TwoSided) == 0);
Assert.IsTrue(segs[744].FrontSector == segs[744].LineDef.FrontSide.Sector);
Assert.IsTrue(segs[744].BackSector == null);
Assert.AreEqual(154, segs[744].Offset.ToDouble(), delta);
Assert.IsTrue(segs[746].Vertex1 == vertices[374]);
Assert.IsTrue(segs[746].Vertex2 == vertices[368]);
Assert.AreEqual(ToRadian(-13828), segs[746].Angle.ToRadian(), delta);
Assert.IsTrue(segs[746].LineDef == lines[451]);
Assert.IsTrue((segs[746].LineDef.Flags & LineFlags.TwoSided) == 0);
Assert.IsTrue(segs[746].FrontSector == segs[746].LineDef.FrontSide.Sector);
Assert.IsTrue(segs[746].BackSector == null);
Assert.AreEqual(0, segs[746].Offset.ToDouble(), delta);
}
}
