public ActionResult Edit([Bind(Include = "TrainingID,Name,TrainingDate,Location,TrainingEnd,NumberOfMeetings,Duration,ExpireDate,ExpirationDate,QualificationID")] Training training, int[] subsectors)
{
if (ModelState.IsValid)
{
db.Entry(training).State = EntityState.Modified;
// training.TrainingSubSectors.Clear();
var SubSectorToTrainingList = db.TrainingSubSectors.Where(t => t.TrainingID == training.TrainingID).ToList();
foreach (var train in SubSectorToTrainingList)
{
db.TrainingSubSectors.Remove(train);
}
foreach (var id in subsectors)
{
SubSector sub = db.SubSectors.Find(id);
training.AddSubSector(sub);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
var sectorlist = (from s in training.TrainingSubSectors
select s.SubSector.SectorID).ToArray();
var subsectorlist = (from s in training.TrainingSubSectors
select s.SubSectorID).ToArray();
ViewBag.Sectors = new MultiSelectList(db.Sectors, "SectorID", "SectorType", sectorlist);
ViewBag.subSectors = new MultiSelectList(db.SubSectors, "SubSectorID", "SubSectortype", subsectorlist);
ViewBag.QualificationID = new MultiSelectList(db.Qualification, "QualificationID", "Name");
return(View(training));
}
public IEnumerable <SubSector> GetSubSector(SubSector subSector)
{
using (DemsifyEntities dataContext = new DemsifyEntities())
{
ObjectParameter totalPageCount = new ObjectParameter("TotalPageCount", typeof(int));
ObjectParameter totalRecord = new ObjectParameter("TotalRecord", typeof(int));
var subSectors = dataContext.SubSectorGet(subSector.SubSectorId, subSector.SectorId, Utility.TrimString(subSector.SearchText), subSector.IsActive, subSector.PageNumber, subSector.PageSize, subSector.IsPagingRequired, Utility.TrimString(subSector.OrderBy), Utility.TrimString(subSector.OrderByDirection), totalPageCount, totalRecord).ToList();
var subSectorList = new List <SubSector>();
foreach (var subSectorDetail in subSectors)
{
subSectorList.Add(new SubSector()
{
SubSectorId = subSectorDetail.SubSectorId,
SectorId = subSectorDetail.SectorId,
Name = subSectorDetail.Name,
IsActive = subSectorDetail.IsActive,
TotalPageCount = Convert.ToInt32(totalPageCount.Value),
TotalRecord = Convert.ToInt32(totalRecord.Value)
});
}
return(subSectorList);
}
}
public ActionResult GetSelectedSectorCodeField(int SubSectorID)
{
FM_Sector model = new FM_Sector();
SubSector tblSector = (from e in TOSSDB.SubSectors where e.SubSectorID == SubSectorID select e).FirstOrDefault();
model.SubsectorCodeID = tblSector.SubSectorCode;
return(PartialView("SubSector/_DynamicLSectorCode", model));
}
//Delete SubSector
public ActionResult DeleteSubSectors(FM_Sector model, int SubSectorID)
{
SubSector tblSubSector = (from e in TOSSDB.SubSectors where e.SubSectorID == SubSectorID select e).FirstOrDefault();
TOSSDB.SubSectors.Remove(tblSubSector);
TOSSDB.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult DeleteConfirmed(Guid id)
{
SubSector subSector = db.SubSectors.Find(id);
db.SubSectors.Remove(subSector);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IHttpActionResult UpdateSubSector(UpdateSubSectorRequest updateSubSectorRequest)
{
var responses = new Responses();
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (Utility.UserId < 0)
{
return(BadRequest(Utility.INVALID_USER));
}
var subSector = new SubSector()
{
SubSectorId = updateSubSectorRequest.SubSectorId,
SectorId = updateSubSectorRequest.SectorId,
Name = updateSubSectorRequest.Name,
ModifiedBy = Utility.UserId
};
int result = iSubSector.UpdateSubSector(subSector);
switch (result)
{
case 1:
responses.Status = Utility.SUCCESS_STATUS_RESPONSE;
responses.Description = "SubSector updated successfully.";
break;
case -2:
responses.Status = Utility.ERROR_STATUS_RESPONSE;
responses.Description = "SubSector already exists.";
break;
case -3:
responses.Status = Utility.ERROR_STATUS_RESPONSE;
responses.Description = "SubSector doesn't exist.";
break;
default:
responses.Status = Utility.ERROR_STATUS_RESPONSE;
responses.Description = "Error while updating SubSector.";
break;
}
}
catch (Exception ex)
{
responses.Status = Utility.ERROR_STATUS_RESPONSE;
responses.Description = "Error while updating SubSector.";
Utility.WriteLog("UpdateSubSector", updateSubSectorRequest, "Error while updating SubSector. (SubSectorAdminController)", ex.ToString());
}
return(Ok(responses));
}
//Get Update SubSector
public ActionResult Get_UpdateSubSector(FM_Sector model, int SubSectorID)
{
SubSector tblSubSector = (from e in TOSSDB.SubSectors where e.SubSectorID == SubSectorID select e).FirstOrDefault();
model.getSubSectorcolumns.SubSectorID = tblSubSector.SubSectorID;
model.SubSectorNameTempID = tblSubSector.SectorID;
model.getSubSectorcolumns.SubSectorName = tblSubSector.SubSectorName;
model.getSubSectorcolumns.SubSectorCode = tblSubSector.SubSectorCode;
return(PartialView("SubSector/_UpdateSubSectors", model));
}
public ActionResult Edit(SubSector subSector)
{
if (ModelState.IsValid)
{
db.Entry(subSector).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(subSector));
}
public ActionResult Edit([Bind(Include = "SubSectorId,SubSectorName,DateEntered,DateModified,CreatedByUserId,ModifiedByUserId")] SubSector subSector)
{
if (ModelState.IsValid)
{
db.Entry(subSector).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(subSector));
}
//Update SubSector
public ActionResult UpdateSubSector(FM_Sector model)
{
SubSector tblSubSector = (from e in TOSSDB.SubSectors where e.SubSectorID == model.getSubSectorcolumns.SubSectorID select e).FirstOrDefault();
tblSubSector.SectorID = model.SubSectorNameID;
tblSubSector.SubSectorName = model.getSubSectorcolumns.SubSectorName;
tblSubSector.SubSectorCode = model.getSubSectorcolumns.SubSectorCode;
TOSSDB.Entry(tblSubSector);
TOSSDB.SaveChanges();
return(PartialView("SubSector/_UpdateSubSectors", model));
}
//Add SubSector
public JsonResult AddSubSector(FM_Sector model)
{
SubSector tblSubSector = new SubSector();
tblSubSector.SectorID = model.SubSectorNameID;
tblSubSector.SubSectorName = model.getSubSectorcolumns.SubSectorName;
tblSubSector.SubSectorCode = model.getSubSectorcolumns.SubSectorCode;
TOSSDB.SubSectors.Add(tblSubSector);
TOSSDB.SaveChanges();
return(Json(tblSubSector));
}
public ActionResult Create(SubSector subSector)
{
if (ModelState.IsValid)
{
db.SubSectors.Add(subSector);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(subSector));
}
public FM_Sector()
{
getSector = new List <Sector>();
getSectorcolumns = new Sector();
getSectorList = new List <SectorList>();
getSubSector = new List <SubSector>();
getSubSectorcolumns = new SubSector();
getSubSectorList = new List <SubSectorList>();
}
public int DeleteSubSector(SubSector subSector)
{
using (DemsifyEntities dataContext = new DemsifyEntities())
{
ObjectParameter result = new ObjectParameter("Result", typeof(int));
dataContext.SubSectorDelete(subSector.SubSectorId, subSector.ModifiedBy, result);
return(Convert.ToInt32(result.Value));
}
}
public int AddSubSector(SubSector subSector)
{
using (DemsifyEntities dataContext = new DemsifyEntities())
{
ObjectParameter result = new ObjectParameter("Result", typeof(int));
dataContext.SubSectorAdd(subSector.SectorId, Utility.TrimString(subSector.Name), subSector.CreatedBy, result);
return(Convert.ToInt32(result.Value));
}
}
public ActionResult Create([Bind(Include = "SubSectorId,SubSectorName,DateEntered,DateModified,CreatedByUserId,ModifiedByUserId")] SubSector subSector)
{
if (ModelState.IsValid)
{
subSector.SubSectorId = Guid.NewGuid();
db.SubSectors.Add(subSector);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(subSector));
}
// GET: SubSectors/Delete/5
public ActionResult Delete(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SubSector subSector = db.SubSectors.Find(id);
if (subSector == null)
{
return(HttpNotFound());
}
return(View(subSector));
}
// GET: subSector/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SubSector subSector = db.SubSectors.Find(id);
if (subSector == null)
{
return(HttpNotFound());
}
ViewBag.SectorID = new MultiSelectList(db.Sectors, "SectorID", "SectorType");
return(View(subSector));
}
public static SubSector Generate(SubsectorDensity density = SubsectorDensity.Standard)
{
SubSector output = new SubSector();
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 10; j++)
{
if (IsSystemPresent(density))
{
var stellarSystem = StellarSystemGenerator.Generate(i, j);
}
}
}
return(output);
}
public async Task <SubSector> SaveSubSector([FromBody] SubSector PostedSubSector)
{
if (!ModelState.IsValid)
{
throw new ApiException("Model binding failed.", 500);
}
if (!_SubSectorRepo.Validate(PostedSubSector))
{
//throw new ApiException(_SubSectorRepo.ErrorMessage, 500, _SubSectorRepo.ValidationErrors);
if (!await _SubSectorRepo.SaveAsync(PostedSubSector))
{
throw new ApiException(_SubSectorRepo.ErrorMessage);
}
}
return(PostedSubSector);
}
public JsonResult Create(UISubSector uISubSector)
{
try
{
using (var repository = new Repository <SubSector>())
{
if (uISubSector.Id != 0)
{
var subSector = repository.Filter(q => q.Id == uISubSector.Id).FirstOrDefault();
if (subSector != null && !string.IsNullOrEmpty(subSector.SubSectorName))
{
subSector.SubSectorName = uISubSector.SubSectorName;
subSector.SectorId = uISubSector.SectorId;
subSector.UpdateDate = DateTime.Now;
repository.Update(subSector);
}
}
else
{
var count = repository.All().Max(q => q.Id);
var subSector = new SubSector()
{
Id = ++count,
SubSectorName = uISubSector.SubSectorName,
SectorId = uISubSector.SectorId,
CreateDate = DateTime.Now,
Sectors = repository.AssessmentContext.sectors.FirstOrDefault(q => q.Id == uISubSector.SectorId)
};
repository.Create(subSector);
}
repository.SaveChanges();
}
// TODO: Add insert logic here
// return RedirectToAction("Index");
}
catch (Exception ex)
{
UserException.LogException(ex);
return(Json(Utilities.Failiure, JsonRequestBehavior.AllowGet));
}
return(Json(Utilities.Success, JsonRequestBehavior.AllowGet));
}
public IHttpActionResult AddSubSector(AddSubSectorRequest addSubSectorRequest)
{
var responses = new Responses();
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var subSector = new SubSector()
{
SectorId = addSubSectorRequest.SectorId,
Name = addSubSectorRequest.Name,
CreatedBy = Utility.UserId
};
int result = iSubSector.AddSubSector(subSector);
if (result > 0)
{
responses.Status = Utility.SUCCESS_STATUS_RESPONSE;
responses.Description = "SubSector added successfully.";
}
else if (result == -2)
{
responses.Status = Utility.ERROR_STATUS_RESPONSE;
responses.Description = "SubSector alread exists.";
}
else
{
responses.Status = Utility.ERROR_STATUS_RESPONSE;
responses.Description = "Error while adding SubSector.";
}
}
catch (Exception ex)
{
responses.Status = Utility.ERROR_STATUS_RESPONSE;
responses.Description = "Error while adding SubSector.";
Utility.WriteLog("AddSubSector", addSubSectorRequest, "Error while adding SubSector. (SubSectorAdminController)", ex.ToString());
}
return(Ok(responses));
}
public ActionResult Create([Bind(Include = "TrainingID,Name,TrainingDate,Location,TrainingEnd,NumberOfMeetings,Duration,ExpireDate,ExpirationDate,QualificationID")] Training training, int[] subsectors)
{
if (ModelState.IsValid)
{
foreach (var id in subsectors)
{
SubSector subsector = db.SubSectors.Find(id);
training.AddSubSector(subsector);
}
db.Trainings.Add(training);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Sectors = new MultiSelectList(db.Sectors, "SectorID", "SectorType");
ViewBag.subSectors = new MultiSelectList(db.SubSectors, "SubSectorID", "SubSectortype");
ViewBag.QualificationID = new SelectList(db.Qualification, "QualificationID", "Name");
return(View(training));
}
public IHttpActionResult GetSubSector([FromUri] GetSubSectorRequest getSubSectorRequest)
{
var responses = new Responses();
try
{
if (Utility.UserId < 0)
{
return(BadRequest(Utility.INVALID_USER));
}
if (getSubSectorRequest == null)
{
getSubSectorRequest = new GetSubSectorRequest();
}
if (getSubSectorRequest.PageSize == null)
{
getSubSectorRequest.PageSize = Convert.ToInt32(ConfigurationManager.AppSettings["PageSize"]);
}
var subSector = new SubSector()
{
SubSectorId = getSubSectorRequest.SubSectorId,
SectorId = getSubSectorRequest.SectorId,
SearchText = getSubSectorRequest.SearchText,
IsActive = getSubSectorRequest.IsActive,
PageNumber = getSubSectorRequest.PageNumber,
PageSize = Convert.ToInt32(getSubSectorRequest.PageSize),
IsPagingRequired = (getSubSectorRequest.PageNumber != null) ? true : false,
OrderBy = getSubSectorRequest.OrderBy,
OrderByDirection = getSubSectorRequest.OrderByDirection
};
var subSectors = iSubSector.GetSubSector(subSector);
var subSectorList = new List <GetSubSectorResponse>();
foreach (var subSectorDetail in subSectors)
{
subSectorList.Add(new GetSubSectorResponse()
{
SubSectorId = Convert.ToInt32(subSectorDetail.SubSectorId),
SectorId = subSectorDetail.SectorId,
Name = subSectorDetail.Name,
IsActive = Convert.ToBoolean(subSectorDetail.IsActive),
CreatedBy = subSectorDetail.CreatedBy,
TotalPageCount = subSectorDetail.TotalPageCount,
TotalRecord = subSectorDetail.TotalRecord
});
}
responses.Status = Utility.SUCCESS_STATUS_RESPONSE;
responses.Description = "SubSector retrieved successfully";
responses.Response = subSectorList.OrderBy(x => x.Name).ToList();
}
catch (Exception ex)
{
responses.Status = Utility.ERROR_STATUS_RESPONSE;
responses.Description = "Error while retrieving SubSector.";
Utility.WriteLog("GetSubSector", getSubSectorRequest, "Error while retrieving SubSector. (SectorUserController)", ex.ToString());
}
return(Ok(responses));
}
private void LoadWAD(string WADPath, string LevelName)
{
byte[] buffer;
int i;
GD.Print($"Opening {WADPath}...");
File file = new File();
file.Open(WADPath, File.ModeFlags.Read);
if (file.Open(WADPath, File.ModeFlags.Read) != Godot.Error.Ok)
{
GD.Print($"Failed to open WAD file {WADPath}");
return;
}
if (printDebugInfo)
{
GD.Print("READING HEADER...");
}
Header header = new Header();
header.Type = Decode32AsString(file);
header.LumpNum = file.Get32();
header.DirOffset = file.Get32();
GD.Print($"{this.WADPath} is {header.Type}");
if (printDebugInfo)
{
GD.Print("READING LUMPS");
}
Lump lumpMapname = new Lump();
Lump lumpThings = new Lump();
Lump lumpLinedefs = new Lump();
Lump lumpSidedefs = new Lump();
Lump lumpVertexes = new Lump();
Lump lumpSegs = new Lump();
Lump lumpSubsectors = new Lump();
Lump lumpNodes = new Lump();
Lump lumpSectors = new Lump();
Lump lumpReject = new Lump();
Lump lumpBlockmap = new Lump();
bool first = true;
bool breakAfter = false;
file.Seek(header.DirOffset);
for (int j = 0; j < header.LumpNum; j++)
{
Lump lump = ReadLump(file);
if (first)
{
lumpMapname = lump;
first = false;
}
switch (lump.Name)
{
case "THINGS":
lumpThings = lump;
break;
case "LINEDEFS":
lumpLinedefs = lump;
break;
case "SIDEDEFS":
lumpSidedefs = lump;
break;
case "VERTEXES":
lumpVertexes = lump;
break;
case "SEGS":
lumpSegs = lump;
break;
case "SSECTORS":
lumpSubsectors = lump;
break;
case "NODES":
lumpNodes = lump;
break;
case "SECTORS":
lumpSectors = lump;
break;
case "REJECT":
lumpReject = lump;
break;
case "BLOCKMAP":
lumpBlockmap = lump;
if (breakAfter)
{
break;
}
break;
default:
if (lump.Name == levelName)
{
breakAfter = true;
}
break;
}
}
if (printDebugInfo)
{
GD.Print($"Internal map name: {lumpMapname.Name}");
}
if (printDebugInfo)
{
GD.Print($"READING THINGS...");
}
file.Seek(lumpThings.Offset);
buffer = file.GetBuffer((int)lumpThings.Size);
Thing[] things = new Thing[lumpThings.Size];
i = 0;
while (i < buffer.Length)
{
Thing thing = new Thing();
thing.X = ToShort(buffer[i], buffer[i + 1]);
thing.Y = ToShort(buffer[i + 2], buffer[i + 3]);
thing.Angle = ToShort(buffer[i + 4], buffer[i + 5]);
thing.Type = ToShort(buffer[i + 6], buffer[i + 7]);
thing.Options = ToShort(buffer[i + 8], buffer[i + 9]);
things.Append(thing);
i += 10;
}
if (printDebugInfo)
{
GD.Print("READING LINEDEFS...");
}
file.Seek(lumpLinedefs.Offset);
buffer = file.GetBuffer((int)lumpLinedefs.Size);
Linedef[] linedefs = new Linedef[lumpLinedefs.Size];
i = 0;
int k = 0;
while (i < buffer.Length)
{
Linedef linedef = new Linedef();
linedef.StartVertex = ToShort(buffer[i], buffer[i + 1]);
linedef.EndVertex = ToShort(buffer[i + 2], buffer[i + 3]);
linedef.Flags = ToShort(buffer[i + 4], buffer[i + 5]);
linedef.Type = ToShort(buffer[i + 6], buffer[i + 7]);
linedef.Trigger = ToShort(buffer[i + 8], buffer[i + 9]);
linedef.RightSidedef = ToShort(buffer[i + 10], buffer[i + 11]);
linedef.LeftSidedef = ToShort(buffer[i + 12], buffer[i + 13]);
//linedefs.Append(linedef);
linedefs[k++] = linedef;
i += 14;
}
if (printDebugInfo)
{
GD.Print("READING SIDEDEFS...");
}
file.Seek(lumpSidedefs.Offset);
buffer = file.GetBuffer((int)lumpSidedefs.Size);
Sidedef[] sieddefs = new Sidedef[lumpSidedefs.Size];
i = 0;
while (i < buffer.Length)
{
Sidedef sidedef = new Sidedef();
sidedef.XOffset = ToShort(buffer[i], buffer[i + 1]);
sidedef.YOffset = ToShort(buffer[i + 2], buffer[i + 3]);
sidedef.UpperTexture = Combine8BytesToString(buffer[i + 4], buffer[i + 5], buffer[i + 6], buffer[i + 7],
buffer[i + 8], buffer[i + 9], buffer[i + 10], buffer[i + 11]);
sidedef.LowerTexture = Combine8BytesToString(buffer[i + 12], buffer[i + 13], buffer[i + 14], buffer[i + 15],
buffer[i + 16], buffer[i + 17], buffer[i + 18], buffer[i + 19]);
sidedef.MiddleTexture = Combine8BytesToString(buffer[i + 20], buffer[i + 21], buffer[i + 22],
buffer[i + 23], buffer[i + 24], buffer[i + 25], buffer[i + 26], buffer[i + 27]);
sidedef.Sector = ToShort(buffer[i + 28], buffer[i + 29]);
sieddefs.Append(sidedef);
i += 30;
}
if (printDebugInfo)
{
GD.Print("READING VERTEXES...");
}
file.Seek(lumpVertexes.Offset);
buffer = buffer = file.GetBuffer((int)lumpVertexes.Size);
Vertex[] vertexes = new Vertex[lumpVertexes.Size];
i = 0;
k = 0;
while (i < buffer.Length)
{
float x = ToShort(buffer[i], buffer[i + 1]) * scale;
float y = ToShort(buffer[i + 2], buffer[i + 3]) * scale;
Vertex vertex = new Vertex();
vertex.X = x;
vertex.Y = y;
vertexes[k] = vertex;
k += 1;
i += 4;
}
if (printDebugInfo)
{
GD.Print("READING SUB-SECTORS...");
}
file.Seek(lumpSubsectors.Offset);
buffer = buffer = file.GetBuffer((int)lumpSubsectors.Size);
SubSector[] subSectors = new SubSector[lumpSubsectors.Size];
i = 0;
while (i < buffer.Length)
{
SubSector subSector = new SubSector();
subSector.SegCount = ToShort(buffer[i], buffer[i + 1]);
subSector.SegNum = ToShort(buffer[i + 2], buffer[i + 3]);
subSectors.Append(subSector);
i += 4;
}
if (printDebugInfo)
{
GD.Print("READING NODES...");
}
file.Seek(lumpNodes.Offset);
buffer = buffer = file.GetBuffer((int)lumpNodes.Size);
Node[] nodes = new Node[lumpNodes.Size];
i = 0;
while (i < buffer.Length)
{
Node node = new Node();
node.X = ToShort(buffer[i], buffer[i + 1]);
node.Y = ToShort(buffer[i + 2], buffer[i + 3]);
node.DX = ToShort(buffer[i + 4], buffer[i + 5]);
node.DY = ToShort(buffer[i + 6], buffer[i + 7]);
node.YUpperRight = ToShort(buffer[i + 8], buffer[i + 9]);
node.YLowerRight = ToShort(buffer[i + 10], buffer[i + 11]);
node.XLowerRight = ToShort(buffer[i + 12], buffer[i + 13]);
node.XUpperRight = ToShort(buffer[i + 14], buffer[i + 15]);
node.YUpperLeft = ToShort(buffer[i + 16], buffer[i + 17]);
node.YLowerLeft = ToShort(buffer[i + 18], buffer[i + 19]);
node.XLowerLeft = ToShort(buffer[i + 20], buffer[i + 20]);
node.XUpperLeft = ToShort(buffer[i + 22], buffer[i + 23]);
node.NodeRight = ToShort(buffer[i + 24], buffer[i + 25]);
node.NodeLeft = ToShort(buffer[i + 26], buffer[i + 27]);
i += 28;
}
if (printDebugInfo)
{
GD.Print("READING SECTORS...");
}
file.Seek(lumpSectors.Offset);
buffer = buffer = file.GetBuffer((int)lumpSectors.Size);
Sector[] sectors = new Sector[lumpSectors.Size];
i = 0;
while (i < buffer.Length)
{
Sector sector = new Sector();
sector.FloorHeight = ToShort(buffer[i], buffer[i + 1]);
sector.FloorHeight = ToShort(buffer[i + 1], buffer[i + 3]);
sector.FloorTexture = Combine8BytesToString(buffer[i + 4], buffer[i + 5], buffer[i + 6], buffer[i + 7],
buffer[i + 8], buffer[i + 9], buffer[i + 10], buffer[i + 11]);
sector.CeilTexture = Combine8BytesToString(buffer[i + 12], buffer[i + 13], buffer[i + 14], buffer[i + 15],
buffer[i + 16], buffer[i + 17], buffer[i + 18], buffer[i + 19]);
sector.LightLevel = ToShort(buffer[i + 20], buffer[i + 21]);
sector.Special = ToShort(buffer[i + 22], buffer[i + 23]);
sector.Tag = ToShort(buffer[i + 24], buffer[i + 25]);
sectors.Append(sector);
i += 26;
}
file.Close();
if (printDebugInfo)
{
GD.Print("BUILDING GEOMETRY");
}
foreach (var ld in linedefs)
{
if (ld == null)
{
continue;
}
Vertex vertex1 = vertexes[ld.StartVertex];
Vertex vertex2 = vertexes[ld.EndVertex];
ImmediateGeometry geometry = new ImmediateGeometry();
geometry.MaterialOverride = _surfaceMaterial;
geometry.Begin(Mesh.PrimitiveType.Lines);
if (ld.Type != 0)
{
geometry.SetColor(new Color(1, 1, 0));
}
else
{
geometry.SetColor(new Color(1, 0, 0));
}
geometry.AddVertex(new Vector3(vertex1.X, 0, vertex1.Y));
geometry.AddVertex(new Vector3(vertex2.X, 0, vertex2.Y));
geometry.End();
AddChild(geometry);
}
}
async Task Game()
{
Lump[] lumps;
try
{
using (var iwad = File.Open(@"E:\Steam\steamapps\common\DOOM 3 BFG Edition\base\wads\DOOM2.WAD", FileMode.Open, FileAccess.Read, FileShare.Read))
{
byte[] rec = new byte[16];
await iwad.ReadAsync(rec, 0, 12);
int num = BitConverter.ToInt32(rec, 4);
int ofs = BitConverter.ToInt32(rec, 8);
iwad.Seek((long)ofs, SeekOrigin.Begin);
// Read the lump table:
byte[] dir = new byte[16 * num];
await iwad.ReadAsync(dir, 0, 16 *num);
lumps = new Lump[num];
for (int i = 0; i < num; ++i)
{
// Read the lump data from the table:
int position = BitConverter.ToInt32(dir, i * 16 + 0);
int size = BitConverter.ToInt32(dir, i * 16 + 4);
string name = Encoding.ASCII.GetString(dir, i * 16 + 8, 8).TrimEnd(new char[] { '\0' });
byte[] data;
if (size > 0)
{
data = new byte[size];
iwad.Seek((long)position, SeekOrigin.Begin);
await iwad.ReadAsync(data, 0, size);
}
else
{
data = null;
}
// Record the lump and its data:
lumps[i] = new Lump(name, position, size, data);
}
}
int ml = FindLump(lumps, mapLumpName);
// Find center of map:
var minPos = new Vertex(Int16.MaxValue, Int16.MaxValue);
var maxPos = new Vertex(Int16.MinValue, Int16.MinValue);
// Read vertexes:
var vertexesLump = lumps[ml + (int)MapLump.VERTEXES];
int numVertexes = vertexesLump.Size / (2 + 2);
vertexes = new Vertex[numVertexes];
for (int i = 0; i < numVertexes; ++i)
{
short x = BitConverter.ToInt16(vertexesLump.Data, i * 2 * sizeof(Int16));
short y = BitConverter.ToInt16(vertexesLump.Data, i * 2 * sizeof(Int16) + sizeof(Int16));
if (x < minPos.X)
{
minPos = new Vertex(x, minPos.Y);
}
if (y < minPos.Y)
{
minPos = new Vertex(minPos.X, y);
}
if (x > maxPos.X)
{
maxPos = new Vertex(x, maxPos.Y);
}
if (y > maxPos.Y)
{
maxPos = new Vertex(maxPos.X, y);
}
vertexes[i] = new Vertex(x, y);
}
// Calculate center:
int mapw = (maxPos.X - minPos.X);
int maph = (maxPos.Y - minPos.Y);
var center = new Vertex(mapw / 2 + minPos.X, maph / 2 + minPos.Y);
MapCoordToVector3(new Vertex3(center, 64), out centerPos);
cameraDistance = Math.Max(mapw, maph) / scale;
cameraHeight = cameraDistance * 0.8f;
// Read sectors:
var sectorsLump = lumps[ml + (int)MapLump.SECTORS];
const int sectorSize = (sizeof(short) * 5) + (8 * 2);
int numSectors = sectorsLump.Size / sectorSize;
sectors = new Sector[numSectors];
for (int i = 0; i < numSectors; ++i)
{
short floorheight = BitConverter.ToInt16(sectorsLump.Data, (i * sectorSize) + (sizeof(short) * 0));
short ceilingheight = BitConverter.ToInt16(sectorsLump.Data, (i * sectorSize) + (sizeof(short) * 1));
string floorpic = Encoding.ASCII.GetString(sectorsLump.Data, (i * sectorSize) + 0 + (sizeof(short) * 2), 8).ASCIIZ();
string ceilingpic = Encoding.ASCII.GetString(sectorsLump.Data, (i * sectorSize) + 8 + (sizeof(short) * 2), 8).ASCIIZ();
short lightlevel = BitConverter.ToInt16(sectorsLump.Data, (i * sectorSize) + 16 + (sizeof(short) * 2));
short special = BitConverter.ToInt16(sectorsLump.Data, (i * sectorSize) + 16 + (sizeof(short) * 3));
short tag = BitConverter.ToInt16(sectorsLump.Data, (i * sectorSize) + 16 + (sizeof(short) * 4));
sectors[i] = new Sector(floorheight, ceilingheight, floorpic, ceilingpic, lightlevel, special, tag);
}
// Read sidedefs:
var sidedefsLump = lumps[ml + (int)MapLump.SIDEDEFS];
const int sidedefSize = (sizeof(short) * 3) + (8 * 3);
int numSidedefs = sidedefsLump.Size / sidedefSize;
sidedefs = new SideDef[numSidedefs];
for (int i = 0; i < numSidedefs; ++i)
{
short textureoffset = BitConverter.ToInt16(sidedefsLump.Data, (i * sidedefSize) + (sizeof(short) * 0));
short rowoffset = BitConverter.ToInt16(sidedefsLump.Data, (i * sidedefSize) + (sizeof(short) * 1));
string toptexture = Encoding.ASCII.GetString(sidedefsLump.Data, (i * sidedefSize) + 0 + (sizeof(short) * 2), 8).ASCIIZ();
string bottomtexture = Encoding.ASCII.GetString(sidedefsLump.Data, (i * sidedefSize) + 8 + (sizeof(short) * 2), 8).ASCIIZ();
string midtexture = Encoding.ASCII.GetString(sidedefsLump.Data, (i * sidedefSize) + 16 + (sizeof(short) * 2), 8).ASCIIZ();
// Front sector, towards viewer.
short sector = BitConverter.ToInt16(sidedefsLump.Data, (i * sidedefSize) + 24 + (sizeof(short) * 2));
sidedefs[i] = new SideDef(textureoffset, rowoffset, toptexture, bottomtexture, midtexture, sectors[sector]);
}
// Read linedefs:
var linedefsLump = lumps[ml + (int)MapLump.LINEDEFS];
const int linedefSize = sizeof(short) * 7;
int numLineDefs = linedefsLump.Size / linedefSize;
linedefs = new LineDef[numLineDefs];
var verts = new ListSet <Vertex3>(numVertexes * 4);
var quads = new List <Quad>(numLineDefs * 3);
for (int i = 0; i < numLineDefs; ++i)
{
short v1 = BitConverter.ToInt16(linedefsLump.Data, (i * linedefSize) + (sizeof(short) * 0));
short v2 = BitConverter.ToInt16(linedefsLump.Data, (i * linedefSize) + (sizeof(short) * 1));
short flags = BitConverter.ToInt16(linedefsLump.Data, (i * linedefSize) + (sizeof(short) * 2));
short special = BitConverter.ToInt16(linedefsLump.Data, (i * linedefSize) + (sizeof(short) * 3));
short tag = BitConverter.ToInt16(linedefsLump.Data, (i * linedefSize) + (sizeof(short) * 4));
short sidenum0 = BitConverter.ToInt16(linedefsLump.Data, (i * linedefSize) + (sizeof(short) * 5));
short sidenum1 = BitConverter.ToInt16(linedefsLump.Data, (i * linedefSize) + (sizeof(short) * 6));
// Look up SideDefs:
SideDef side0, side1;
if (sidenum0 >= 0)
{
side0 = sidedefs[sidenum0];
if (sidenum1 < 0)
{
// One-sided:
side1 = null;
quads.Add(new Quad(
verts.AddReturnIndex(new Vertex3(vertexes[v1], side0.Sector.Floorheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v1], side0.Sector.Ceilingheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v2], side0.Sector.Ceilingheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v2], side0.Sector.Floorheight))
));
}
else
{
// Two-sided:
side1 = sidedefs[sidenum1];
if (side1.Sector.Floorheight < side0.Sector.Floorheight)
{
quads.Add(new Quad(
verts.AddReturnIndex(new Vertex3(vertexes[v1], side0.Sector.Floorheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v1], side1.Sector.Floorheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v2], side1.Sector.Floorheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v2], side0.Sector.Floorheight))
));
}
else if (side1.Sector.Floorheight >= side0.Sector.Floorheight)
{
quads.Add(new Quad(
verts.AddReturnIndex(new Vertex3(vertexes[v1], side0.Sector.Floorheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v1], side1.Sector.Floorheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v2], side1.Sector.Floorheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v2], side0.Sector.Floorheight))
));
}
if (side1.Sector.Ceilingheight < side0.Sector.Ceilingheight)
{
quads.Add(new Quad(
verts.AddReturnIndex(new Vertex3(vertexes[v1], side1.Sector.Ceilingheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v1], side0.Sector.Ceilingheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v2], side0.Sector.Ceilingheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v2], side1.Sector.Ceilingheight))
));
}
else if (side1.Sector.Ceilingheight >= side0.Sector.Ceilingheight)
{
quads.Add(new Quad(
verts.AddReturnIndex(new Vertex3(vertexes[v1], side0.Sector.Ceilingheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v1], side1.Sector.Ceilingheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v2], side1.Sector.Ceilingheight)),
verts.AddReturnIndex(new Vertex3(vertexes[v2], side0.Sector.Ceilingheight))
));
}
}
}
else
{
throw new Exception("FAIL");
}
linedefs[i] = new LineDef(v1, v2, flags, special, tag, side0, side1);
}
quadIndices = quads.ToArray();
// Read segs:
const int segSize = sizeof(short) * 6;
var segsLump = lumps[ml + (int)MapLump.SEGS];
int numSegs = segsLump.Size / segSize;
segs = new LineSeg[numSegs];
for (int i = 0; i < numSegs; ++i)
{
short v1 = BitConverter.ToInt16(segsLump.Data, (i * segSize) + (sizeof(short) * 0));
short v2 = BitConverter.ToInt16(segsLump.Data, (i * segSize) + (sizeof(short) * 1));
short angle = BitConverter.ToInt16(segsLump.Data, (i * segSize) + (sizeof(short) * 2));
short linedef = BitConverter.ToInt16(segsLump.Data, (i * segSize) + (sizeof(short) * 3));
short side = BitConverter.ToInt16(segsLump.Data, (i * segSize) + (sizeof(short) * 4));
short offset = BitConverter.ToInt16(segsLump.Data, (i * segSize) + (sizeof(short) * 5));
var ldef = linedefs[linedef];
var sdef = ldef.Side0;
if (side != 0)
{
sdef = ldef.Side1;
}
segs[i] = new LineSeg(v1, v2, angle, ldef, sdef, offset);
}
// Read subsectors:
const int subsectorSize = sizeof(short) * 2;
var subsectorsLump = lumps[ml + (int)MapLump.SSECTORS];
var numSubsectors = subsectorsLump.Size / subsectorSize;
subsectors = new SubSector[numSubsectors];
for (int i = 0; i < numSubsectors; ++i)
{
short numsegs = BitConverter.ToInt16(subsectorsLump.Data, (i * subsectorSize) + (sizeof(short) * 0));
short firstseg = BitConverter.ToInt16(subsectorsLump.Data, (i * subsectorSize) + (sizeof(short) * 1));
// Pull out all the LineSegs for this subsector:
var mysegs = new LineSeg[numsegs];
Array.Copy(segs, firstseg, mysegs, 0, numsegs);
subsectors[i] = new SubSector(mysegs);
// Assert that all line segs in this subsector are in the same sector:
var sector = subsectors[i].Segs[0].Side.Sector;
Debug.Assert(subsectors[i].Segs.All(s => s.Side.Sector == sector));
}
// Build floor + ceil polygons from subsectors:
var fPolys = new List <Polygon>(numSubsectors);
var cPolys = new List <Polygon>(numSubsectors);
int fIndices = 0, cIndices = 0;
for (int i = 0; i < numSubsectors; ++i)
{
var sg = subsectors[i].Segs;
List <int> flind = new List <int>(sg.Length * 2);
List <int> ceind = new List <int>(sg.Length * 2);
for (int j = 0; j < sg.Length; ++j)
{
var seg = sg[j];
if (seg.Side == seg.Line.Side0)
{
flind.Add(verts.AddReturnIndex(new Vertex3(vertexes[seg.V1], seg.Side.Sector.Floorheight)));
flind.Add(verts.AddReturnIndex(new Vertex3(vertexes[seg.V2], seg.Side.Sector.Floorheight)));
ceind.Add(verts.AddReturnIndex(new Vertex3(vertexes[seg.V1], seg.Side.Sector.Ceilingheight)));
ceind.Add(verts.AddReturnIndex(new Vertex3(vertexes[seg.V2], seg.Side.Sector.Ceilingheight)));
}
else
{
flind.Add(verts.AddReturnIndex(new Vertex3(vertexes[seg.V2], seg.Side.Sector.Floorheight)));
flind.Add(verts.AddReturnIndex(new Vertex3(vertexes[seg.V1], seg.Side.Sector.Floorheight)));
ceind.Add(verts.AddReturnIndex(new Vertex3(vertexes[seg.V2], seg.Side.Sector.Ceilingheight)));
ceind.Add(verts.AddReturnIndex(new Vertex3(vertexes[seg.V1], seg.Side.Sector.Ceilingheight)));
}
}
fPolys.Add(new Polygon(flind.ToArray(), fIndices));
fIndices += flind.Count;
cPolys.Add(new Polygon(ceind.ToArray(), cIndices));
cIndices += ceind.Count;
}
// Generate vectors and quad indices for OpenGL:
quadVerts = new Vector3[verts.Count];
for (int i = 0; i < verts.Count; ++i)
{
MapCoordToVector3(verts[i], out quadVerts[i]);
}
floorPolys = fPolys.ToArray();
ceilPolys = cPolys.ToArray();
// Read things:
var thingsLump = lumps[ml + (int)MapLump.THINGS];
const int thingSize = sizeof(short) * 5;
int numThings = thingsLump.Size / thingSize;
for (int i = 0; i < numThings; ++i)
{
short x = BitConverter.ToInt16(thingsLump.Data, (i * thingSize) + (sizeof(short) * 0));
short y = BitConverter.ToInt16(thingsLump.Data, (i * thingSize) + (sizeof(short) * 1));
short angle = BitConverter.ToInt16(thingsLump.Data, (i * thingSize) + (sizeof(short) * 2));
short type = BitConverter.ToInt16(thingsLump.Data, (i * thingSize) + (sizeof(short) * 3));
short options = BitConverter.ToInt16(thingsLump.Data, (i * thingSize) + (sizeof(short) * 4));
#if false
// Player #1 start:
if (type == 1)
{
MapCoordToVector3(x, y, 0, out centerPos);
}
#endif
}
// Game loop:
while (true)
{
// Create a new Frame to update:
next = new Frame();
// Set up the frame state to render:
//next.bg = new Color4((float)rnd.NextDouble(), (float)rnd.NextDouble(), (float)rnd.NextDouble(), 1.0f);
// Set this as the next frame ready to be rendered:
Interlocked.Exchange(ref ready, next);
// Wait for the frame to be rendered:
rendered.WaitOne(16);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
Exit();
return;
}
}
