public List <RoomNode> GenerateRoomsInGivenSpace(List <Node> roomSpaces,
float roomBottomCornerModifier,
float roomTopCornerModifier,
int roomOffset)
{
List <RoomNode> listToReturn = new List <RoomNode>();
foreach (var space in roomSpaces)
{
Vector2Int newBottomLeftPoint = StructureHelper.GenerateBottomLeftCornerBetween(
space.BottomLeftAreaCorner,
space.TopRightAreaCorner,
0.1f, 1); // change values for increase randomess, closeness of rooms
Vector2Int newTopRightPoint = StructureHelper.GenerateBottomLeftCornerBetween(
space.BottomLeftAreaCorner,
space.TopRightAreaCorner,
0.9f, 1); // change values for increase randomess, closeness of rooms
space.BottomLeftAreaCorner = newBottomLeftPoint;
space.TopRightAreaCorner = newTopRightPoint;
space.BottomRightAreaCorner = new Vector2Int(newTopRightPoint.x, newBottomLeftPoint.y);
space.TopLeftAreaCorner = new Vector2Int(newBottomLeftPoint.x, newTopRightPoint.y);
listToReturn.Add((RoomNode)space);
}
return(listToReturn);
}
public ActionResult Update()
{
var keys = new Dictionary <string, object>();
if (Request.QueryString.Count > 0)
{
foreach (var key in Request.QueryString.AllKeys)
{
keys.Add(key, Request.QueryString[key]);
}
}
var data = StructureHelper.Detail(tableSlug, keys);
ViewData.Model = data;
if (Request.HttpMethod == "POST")
{
var form = Request.Form;
foreach (var key in form.AllKeys)
{
data.Data[key] = form[key];
}
//TODO validation
StructureHelper.Update(tableSlug, data.Data);
ViewBag.msg = "updated";
}
return(View());
}
private int GetValidYForNeighourLeftRight(Vector2Int leftNodeUp, Vector2Int leftNodeDown, Vector2Int rightNodeUp, Vector2Int rightNodeDown)
{
if (rightNodeUp.y >= leftNodeUp.y && leftNodeDown.y >= rightNodeDown.y)
{
return(StructureHelper.CalculateMiddlePoint(
leftNodeDown + new Vector2Int(0, modifierDistanceFromWall),
leftNodeUp - new Vector2Int(0, modifierDistanceFromWall + this.corridorWidth)
).y);
}
if (rightNodeUp.y <= leftNodeUp.y && leftNodeDown.y <= rightNodeDown.y)
{
return(StructureHelper.CalculateMiddlePoint(
rightNodeDown + new Vector2Int(0, modifierDistanceFromWall),
rightNodeUp - new Vector2Int(0, modifierDistanceFromWall + this.corridorWidth)
).y);
}
if (leftNodeUp.y >= rightNodeDown.y && leftNodeUp.y <= rightNodeUp.y)
{
return(StructureHelper.CalculateMiddlePoint(
rightNodeDown + new Vector2Int(0, modifierDistanceFromWall),
leftNodeUp - new Vector2Int(0, modifierDistanceFromWall)
).y);
}
if (leftNodeDown.y >= rightNodeDown.y && leftNodeDown.y <= rightNodeUp.y)
{
return(StructureHelper.CalculateMiddlePoint(
leftNodeDown + new Vector2Int(0, modifierDistanceFromWall),
rightNodeUp - new Vector2Int(0, modifierDistanceFromWall + this.corridorWidth)
).y);
}
return(-1);
}
//This function gives us a Y depending on the node position to the other
private int GetYForNeighbor(Vector2Int leftNodeUp, Vector2Int leftNodeDown, Vector2Int rightNodeUp, Vector2Int rightNodeDown)
{
if (rightNodeUp.y >= leftNodeUp.y && leftNodeDown.y >= rightNodeDown.y)
{
return(StructureHelper.CalculateCenter(rightNodeDown + new Vector2Int(0, wallDistanceModifier),
rightNodeUp - new Vector2Int(0, wallDistanceModifier + this.corridorWidth)).y);
}
if (rightNodeUp.y <= leftNodeUp.y && leftNodeDown.y <= rightNodeDown.y)
{
return(StructureHelper.CalculateCenter(leftNodeDown + new Vector2Int(0, wallDistanceModifier),
leftNodeUp - new Vector2Int(0, wallDistanceModifier + this.corridorWidth)).y);
}
if (leftNodeUp.y >= rightNodeDown.y && leftNodeUp.y <= rightNodeUp.y)
{
return(StructureHelper.CalculateCenter(rightNodeDown + new Vector2Int(0, wallDistanceModifier),
leftNodeUp - new Vector2Int(0, wallDistanceModifier + this.corridorWidth)).y);
}
if (leftNodeDown.y >= rightNodeDown.y && leftNodeDown.y <= rightNodeUp.y)
{
return(StructureHelper.CalculateCenter(leftNodeDown + new Vector2Int(0, wallDistanceModifier),
rightNodeUp - new Vector2Int(0, wallDistanceModifier + this.corridorWidth)).y);
}
return(checkValue);
}
private int GetValidXForNeighbourUpDown(Vector2Int bottomNodeLeft,
Vector2Int bottomNodeRight, Vector2Int topNodeLeft, Vector2Int topNodeRight)
{
if (topNodeLeft.x < bottomNodeLeft.x && bottomNodeRight.x < topNodeRight.x)
{
return(StructureHelper.CalculateMiddlePoint(
bottomNodeLeft + new Vector2Int(modifierDistanceFromWall, 0),
bottomNodeRight - new Vector2Int(this.corridorWidth + modifierDistanceFromWall, 0)
).x);
}
if (topNodeLeft.x >= bottomNodeLeft.x && bottomNodeRight.x >= topNodeRight.x)
{
return(StructureHelper.CalculateMiddlePoint(
topNodeLeft + new Vector2Int(modifierDistanceFromWall, 0),
topNodeRight - new Vector2Int(this.corridorWidth + modifierDistanceFromWall, 0)
).x);
}
if (bottomNodeLeft.x >= (topNodeLeft.x) && bottomNodeLeft.x <= topNodeRight.x)
{
return(StructureHelper.CalculateMiddlePoint(
bottomNodeLeft + new Vector2Int(modifierDistanceFromWall, 0),
topNodeRight - new Vector2Int(this.corridorWidth + modifierDistanceFromWall, 0)
).x);
}
if (bottomNodeRight.x <= topNodeRight.x && bottomNodeRight.x >= topNodeLeft.x)
{
return(StructureHelper.CalculateMiddlePoint(
topNodeLeft + new Vector2Int(modifierDistanceFromWall, 0),
bottomNodeRight - new Vector2Int(this.corridorWidth + modifierDistanceFromWall, 0)
).x);
}
return(-1);
}
public void ThenErrorMessageIsDisplayedWithTheFollowingText(string expectedErrorMessage)
{
var loginViewModel = StructureHelper.GetLogin();
var actualErrorMessage = loginViewModel.LoginFailureCause;
StringAssert.AreEqualIgnoringCase(expectedErrorMessage, actualErrorMessage);
}
public void ThenUsernameTextBoxContains(string userName)
{
var loginViewModel = StructureHelper.GetLogin();
var actualUserName = loginViewModel.UserName;
Assert.AreEqual(userName, actualUserName);
}
public void ThenLocalAuthenticationIsAutomaticallySelectedInTheAuthenticationOptionsList()
{
var loginViewModel = StructureHelper.GetLogin();
var selectedLogin = loginViewModel.SelectedLogin;
StringAssert.AreEqualIgnoringCase("Local authentication", selectedLogin);
}
private static ComplianceRootViewModel GetComplianceRoot()
{
var mainViewModel = (MainViewModel)StructureHelper.GetShellActiveItem();
var firstModule = mainViewModel.Modules.OfType <ModuleViewModel>().First(t => t.Name == "Compliance");
return((ComplianceRootViewModel)(firstModule.RootViewModel));
}
public List <Node> CalculateDungeon(int maxPasses, int roomMinWidth, int roomMinLength, float bottomCornerModifier, float topCornerModifier, int roomOffset, int corridorWidth, EnemySpawner enemSpawner, DungeonCreator dungeonCreator, ItemSpawner itemSpawner, ObjectSpawner objSpawner)
{
BinarySpacePartitioner bsp = new BinarySpacePartitioner(dungeonWidth, dungeonLength);
allSpaceNodes = bsp.PrepareNodesCollection(maxPasses, roomMinWidth, roomMinLength);
List <Node> roomSpaces = StructureHelper.TraverseGraphToExtractLowestLeaves(bsp.rootNode);
RoomGenerator roomGenerator = new RoomGenerator(maxPasses, roomMinLength, roomMinWidth);
List <RoomNode> roomList = roomGenerator.GenerateRoomsInGivenSpaces(roomSpaces, bottomCornerModifier, topCornerModifier, roomOffset);
//first room will be the spawn point for the player
RoomNode firstRoom = roomList[0];
UnityEngine.CharacterController player = GameObject.FindWithTag("Player").GetComponent <UnityEngine.CharacterController>();
Vector2Int firstRoomCenter = StructureHelper.CalculateMiddlePoint(firstRoom.BottomLeftCorner, firstRoom.TopRightCorner);
Vector3 newPos = new Vector3(firstRoomCenter.x, 0.0f, firstRoomCenter.y);
player.enabled = false;
player.transform.position = newPos;
player.enabled = true;
//generate spawn points before we add the corridors
for (int i = 0; i < roomList.Count; i++)
{
RoomNode room = roomList[i];
if (enemSpawner != null)
{
GameObject newRoom = new GameObject("RoomObj", typeof(Room), typeof(BoxCollider));
newRoom.tag = "RoomObject";
BoxCollider col = newRoom.GetComponent <BoxCollider>();
col.isTrigger = true;
col.size = new Vector3(1.2f, 1.2f, 1.2f);
Vector2Int roomPos = StructureHelper.CalculateMiddlePoint(room.BottomLeftCorner, room.TopRightCorner);
newRoom.transform.position = new Vector3(roomPos.x, 2, roomPos.y);
Room roomComp = newRoom.GetComponent <Room>();
room.roomObjReference = roomComp;
newRoom.transform.localScale = new Vector3(room.Width, 4, room.Length);
roomComp.enemySpawnPoints = new List <Vector3>();
roomComp.itemSpawnPoints = new List <Vector3>();
roomComp.weaponSpawnPoints = new List <Vector3>();
roomComp.objectSpawnPoints = new List <Vector3>();
roomComp.doors = new List <Transform>();
dungeonCreator.spawnedRooms.Add(roomComp);
if (i != 0)
{
enemSpawner.GenerateEnemySpawnPointsForRoom(room);
itemSpawner.GenerateItemSpawnPointsForRoom(room);
objSpawner.GenerateObjectSpawnPointsForRoom(room);
}
}
}
CorridorGenerator corridorGenerator = new CorridorGenerator();
var corridorList = corridorGenerator.CreateCorridor(allSpaceNodes, corridorWidth);
dungeonCreator.GenerateDoors(corridorList);
return(new List <Node>(roomList).Concat(corridorList).ToList());
}
public List <Node> CalculateDungeon(
int maxIterations,
int roomWidthMin,
int roomLengthMin,
float roomBottomCornerModifier,
float roomTopCornerModifier,
int roomOffset,
int corridorWidth)
{
//splits the room
BinarySpacePartitioner bsp = new BinarySpacePartitioner(dungeonWidth, dungeonLength);
allNodesCollection = bsp.PrepareNodesCollection(maxIterations, roomWidthMin, roomLengthMin);
List <Node> roomSpaces = StructureHelper.TraverseGraphToExtractLowestLeafes(bsp.RootNode);
RoomGenerator roomGenerator = new RoomGenerator(maxIterations, roomLengthMin, roomWidthMin);
List <RoomNode> roomList = roomGenerator.GenerateRoomsInGivenSpace(roomSpaces,
roomBottomCornerModifier,
roomTopCornerModifier,
roomOffset);
CorridorGenerator corridorGenerator = new CorridorGenerator();
var corridorList = corridorGenerator.CreateCorridor(allNodesCollection, corridorWidth);
return(new List <Node>(roomList).Concat(corridorList).ToList());
}
public List <RoomNode> GenerateRoomInGivenSpace(List <Node> roomSpaces, float bottomLeftPointModifier, float topRightPointModifier, int offset)
{
List <RoomNode> listToReturn = new List <RoomNode>();
foreach (Node space in roomSpaces)
{
Vector2Int newBottomLeftPoint = StructureHelper.GenerateBottomLeftCornerBetween(
space.BottomLeftAreaCorner,
space.TopRightAreaCorner,
bottomLeftPointModifier,
offset);
Vector2Int newTopRightPoint = StructureHelper.GenerateTopRightCornerBetween(
space.BottomLeftAreaCorner,
space.TopRightAreaCorner,
topRightPointModifier,
offset);
space.BottomLeftAreaCorner = newBottomLeftPoint;
space.TopRightAreaCorner = newTopRightPoint;
space.BottomRightAreaCorner = new Vector2Int(newTopRightPoint.x, newBottomLeftPoint.y);
space.TopLeftAreaCorner = new Vector2Int(newBottomLeftPoint.x, newTopRightPoint.y);
listToReturn.Add((RoomNode)space);
}
return(listToReturn);
}
//finds the closest X coordinates from adjacent rooms from right corner to clostest right corner
private void ProcessRoomInRelationRightOrLeft(Node structure1, Node structure2)
{
Node leftStructure = null;
List <Node> leftStructureChildren = StructureHelper.TraverseGraphToExtractLowestLeafes(structure1);
Node rightStructure = null;
List <Node> rightStructureChildren = StructureHelper.TraverseGraphToExtractLowestLeafes(structure2);
var sortedLeftStructure = leftStructureChildren.OrderByDescending(child => child.TopRightAreaCorner.x).ToList();
if (sortedLeftStructure.Count == 1)
{
leftStructure = sortedLeftStructure[0];
}
else
{
int maxX = sortedLeftStructure[0].TopRightAreaCorner.x;
sortedLeftStructure = sortedLeftStructure.Where(children => Math.Abs(maxX - children.TopRightAreaCorner.x) < 10).ToList();
int index = UnityEngine.Random.Range(0, sortedLeftStructure.Count);
leftStructure = sortedLeftStructure[index];
}
var possibleNeighboursInRightStructureList = rightStructureChildren.Where(
child => GetValidYForNeighbourLeftRight(
leftStructure.TopRightAreaCorner,
leftStructure.BottomRightAreaCorner,
child.TopLeftAreaCorner,
child.BottomLeftAreaCorner) != -1
).ToList();
if (possibleNeighboursInRightStructureList.Count <= 0)
{
rightStructure = structure2;
}
else
{
rightStructure = possibleNeighboursInRightStructureList[0];
}
int y = GetValidYForNeighbourLeftRight(
leftStructure.TopLeftAreaCorner,
leftStructure.BottomRightAreaCorner,
rightStructure.TopLeftAreaCorner,
rightStructure.BottomLeftAreaCorner);
while (y == -1 && sortedLeftStructure.Count > 1)
{
sortedLeftStructure = sortedLeftStructure.Where(child => child.TopLeftAreaCorner.y != leftStructure.TopLeftAreaCorner.y).ToList();
leftStructure = sortedLeftStructure[0];
y = GetValidYForNeighbourLeftRight(
leftStructure.TopLeftAreaCorner,
leftStructure.BottomRightAreaCorner,
rightStructure.TopLeftAreaCorner,
rightStructure.BottomLeftAreaCorner);
}
BottomLeftAreaCorner = new Vector2Int(leftStructure.BottomRightAreaCorner.x, y);
TopRightAreaCorner = new Vector2Int(rightStructure.TopLeftAreaCorner.x, y + this.corridorWidth);
}
protected override void OnStart(object rootObject)
{
var shell = (ShellViewModel)rootObject;
StructureHelper.SetRootObject(shell);
ScreenExtensions.TryActivate(shell);
ScreenExtensions.TryActivate(StructureHelper.GetLogin());
}
private void ProcessRoomInRelationUpOrDown(Node structure1, Node structure2)
{
Node bottomStructure = null;
List <Node> structureBottmChildren = StructureHelper.TraverseGraphToExtractLowestLeaves(structure1);
Node topStructure = null;
List <Node> structureAboveChildren = StructureHelper.TraverseGraphToExtractLowestLeaves(structure2);
var sortedBottomStructure = structureBottmChildren.OrderByDescending(child => child.TopRightCorner.y).ToList();
if (sortedBottomStructure.Count == 1)
{
bottomStructure = structureBottmChildren[0];
}
else
{
int maxY = sortedBottomStructure[0].TopLeftCorner.y;
sortedBottomStructure = sortedBottomStructure.Where(child => Mathf.Abs(maxY - child.TopLeftCorner.y) < 10).ToList();
int index = UnityEngine.Random.Range(0, sortedBottomStructure.Count);
bottomStructure = sortedBottomStructure[index];
}
var possibleNeighboursInTopStructure = structureAboveChildren.Where(
child => GetValidXForNeighbourUpDown(
bottomStructure.TopLeftCorner,
bottomStructure.TopRightCorner,
child.BottomLeftCorner,
child.BottomRightCorner)
!= -1).OrderBy(child => child.BottomRightCorner.y).ToList();
if (possibleNeighboursInTopStructure.Count == 0)
{
topStructure = structure2;
}
else
{
topStructure = possibleNeighboursInTopStructure[0];
}
int x = GetValidXForNeighbourUpDown(
bottomStructure.TopLeftCorner,
bottomStructure.TopRightCorner,
topStructure.BottomLeftCorner,
topStructure.BottomRightCorner);
while (x == -1 && sortedBottomStructure.Count > 1)
{
sortedBottomStructure = sortedBottomStructure.Where(child => child.TopLeftCorner.x != topStructure.TopLeftCorner.x).ToList();
bottomStructure = sortedBottomStructure[0];
x = GetValidXForNeighbourUpDown(
bottomStructure.TopLeftCorner,
bottomStructure.TopRightCorner,
topStructure.BottomLeftCorner,
topStructure.BottomRightCorner);
}
BottomLeftCorner = new Vector2Int(x, bottomStructure.TopLeftCorner.y);
TopRightCorner = new Vector2Int(x + this.corridorWidth, topStructure.BottomLeftCorner.y);
connectedRooms[0] = ((RoomNode)bottomStructure).roomObjReference;
connectedRooms[1] = ((RoomNode)topStructure).roomObjReference;
}
public WorkItemMigrator(string sourceProjectName, string targetProjectName)
{
_sourceProjectName = sourceProjectName;
_targetProjectName = targetProjectName;
_migratedItemsMap = new Dictionary<int, int>();
_structureHelper = new StructureHelper(sourceProjectName, targetProjectName);
_logger = new Logger(Config.LogFolder);
_logger.ClearLogs();
}
public void Initialization_LoginScreenIsActive()
{
var rootObject = CreateRootObject();
StructureHelper.SetRootObject(rootObject);
var activeItem = StructureHelper.GetShellActiveItem();
Assert.IsInstanceOf <LoginViewModel>(activeItem);
}
public List <Node> CalculateRooms(int maxIteration, int roomWidthMin, int roomLengthMin)
{
BinarySpacePartitioner bsp = new BinarySpacePartitioner(dungeonWidth, dungeonLength);
allSpaceNodes = bsp.PrepareNodesCollection(maxIteration, roomWidthMin, roomLengthMin);
List <Node> roomSpaces = StructureHelper.TraverseGraphToExtractLowestLeafes(bsp.RootNode);
RoomGenerator roomGenerator = new RoomGenerator(maxIteration, roomLengthMin, roomWidthMin);
List <RoomNode> roomList = roomGenerator.GenerateRoomsInGivenSpaces(roomSpaces);
return(new List <Node>(allSpaceNodes));
}
static async Task InstantiateStructures(IEnumerable <IArea> loadedAreas, Dictionary <int, IStructureModel> loadedStructureModels, IGalaxyRegistrationManager rm, IPlayerLocator pl)
{
foreach (IArea a in loadedAreas)
{
var structureIDs = a.GetStructureIDs();
foreach (int id in structureIDs)
{
IStructure s = StructureHelper.InstantiateStructure(loadedStructureModels[id], pl, rm);
a.AddStructure(s);
}
}
}
//This is the same idea as the left/right function just above, but on the X-Axis
private void ProcessRoomRelationUpOrDown(Node structure1, Node structure2)
{
Node bottomStructure = null;
List <Node> structureBottomChildren = StructureHelper.TraverseGraphToExtractLowestLeaf(structure1);
Node topStructure = null;
List <Node> structureTopChildren = StructureHelper.TraverseGraphToExtractLowestLeaf(structure2);
List <Node> sortedBottomStructure = structureBottomChildren.OrderByDescending(child => child.TopRightAreaCorner.y).ToList();
if (sortedBottomStructure.Count == 1)
{
bottomStructure = structureBottomChildren[0];
}
else
{
int maxY = sortedBottomStructure[0].TopLeftAreaCorner.y;
sortedBottomStructure = sortedBottomStructure.Where(child => Mathf.Abs(maxY - child.TopLeftAreaCorner.y) < 10).ToList();
int index = Random.Range(0, sortedBottomStructure.Count);
bottomStructure = sortedBottomStructure[index];
}
List <Node> topStructurePossibleNeighbors = structureTopChildren
.Where(child => GetXForNeighbor(bottomStructure.TopLeftAreaCorner, bottomStructure.TopRightAreaCorner,
child.BottomLeftAreaCorner, child.BottomRightAreaCorner) != 1).OrderBy(child => child.BottomRightAreaCorner.y).ToList();
if (topStructurePossibleNeighbors.Count == 0)
{
topStructure = structure2;
}
else
{
topStructure = topStructurePossibleNeighbors[0];
}
int x = GetXForNeighbor(bottomStructure.TopLeftAreaCorner, bottomStructure.TopRightAreaCorner, topStructure.BottomLeftAreaCorner, topStructure.BottomRightAreaCorner);
while (x == checkValue && sortedBottomStructure.Count > 1)
{
sortedBottomStructure = sortedBottomStructure.Where(child => child.TopLeftAreaCorner.x != topStructure.TopLeftAreaCorner.x).ToList();
bottomStructure = sortedBottomStructure[0];
x = GetXForNeighbor(bottomStructure.TopLeftAreaCorner, bottomStructure.TopRightAreaCorner, topStructure.BottomLeftAreaCorner, topStructure.BottomRightAreaCorner);
}
BottomLeftAreaCorner = new Vector2Int(x, bottomStructure.TopLeftAreaCorner.y);
TopRightAreaCorner = new Vector2Int(x + this.corridorWidth, topStructure.BottomLeftAreaCorner.y);
}
/// <summary>
/// Loads the structures associated with the given object
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
public static async Task <List <IStructure> > LoadStructures(IHasStructures loadMine, IDatabaseManager dbm, IGalaxyRegistrationManager rm, IPlayerLocator pl)
{
var loadedStructureModels = await dbm.GetStructuresAsync(loadMine.GetStructureIDs());
List <IStructure> loadedStructures = new List <IStructure>();
foreach (var ls in loadedStructureModels)
{
IStructure s = StructureHelper.InstantiateStructure(ls, pl, rm);
loadMine.AddStructure(s);
loadedStructures.Add(s);
}
return(loadedStructures);
}
public ActionResult Delete()
{
var keys = new Dictionary <string, object>();
if (Request.QueryString.Count > 0)
{
foreach (var key in Request.QueryString.AllKeys)
{
keys.Add(key, Request.QueryString[key]);
}
}
StructureHelper.Delete(tableSlug, keys);
return(Redirect("/admin/" + tableSlug + "List"));
}
public ActionResult Detail()
{
var keys = new Dictionary <string, object>();
if (Request.QueryString.Count > 0)
{
foreach (var key in Request.QueryString.AllKeys)
{
keys.Add(key, Request.QueryString[key]);
}
}
ViewData.Model = StructureHelper.Detail(tableSlug, keys);
return(View());
}
public object FormatColumn(object val)
{
if (!string.IsNullOrEmpty(this.format))
{
if (this.type == "ref")
{
if (val != null && !string.IsNullOrEmpty(val.ToString()))
{
var selectedValue = val.ToString();
var dict = StructureHelper.GetRelation(format, selectedValue);
return(string.Join(",", dict.Values));
}
}
else if (this.type == "timestamp")
{
var dt = new DateTime(1970, 1, 1).AddSeconds(Convert.ToInt32(val));
return(dt.ToString(this.format));
}
else if (this.type == "datetime" || this.type == "date")
{
if (val != null && !string.IsNullOrEmpty(val.ToString()))
{
return(Convert.ToDateTime(val).ToString(this.format));
}
return(val);
}
else if (this.type == "enum")
{
var arr = this.format.Split('^');
if (arr.First().IndexOf('@') > -1)
{
foreach (var item in arr)
{
var xxxx = item.Split('@');
if (xxxx[0] == val.ToString())
{
return(xxxx[1]);
}
}
}
}
}
return(val);
}
public List <RoomNode> GenerateRoomsInGivenSpaces(List <Node> roomSpaces, float roomBottomCornerModifer, float roomTopCornerModifer, int roomOffset)
{
List <RoomNode> listToReturn = new List <RoomNode>();
foreach (var space in roomSpaces)
{
Vector2Int newBottomLeftPoint = StructureHelper.GenerateBottomLeftCornerBetween(space.BottomLeftAreaCorridor, space.TopRightAreaCorridor, roomBottomCornerModifer, roomOffset);
Vector2Int newTopRightPoint = StructureHelper.GenerateTopRightCornerBetween(space.BottomLeftAreaCorridor, space.TopRightAreaCorridor, roomTopCornerModifer, roomOffset);
space.BottomLeftAreaCorridor = newBottomLeftPoint;
space.TopRightAreaCorridor = newTopRightPoint;
space.BottomRightAreaCorridor = new Vector2Int(newTopRightPoint.x, newBottomLeftPoint.y);
space.TopLeftAreaCorridor = new Vector2Int(newBottomLeftPoint.x, newTopRightPoint.y);
listToReturn.Add((RoomNode)space);
}
return(listToReturn);
}
// GET: Admin
public ActionResult List(int pageIndex = 0, int pageSize = 20)
{
var result = new ResultList();
result.pageIndex = pageIndex;
result.pageSize = pageSize;
Dictionary <string, object> paramList = new Dictionary <string, object>();
foreach (var q in Request.QueryString.AllKeys)
{
if (q != "pageIndex" && q != "pageSize" && !string.IsNullOrEmpty(Request.QueryString[q]))
{
paramList.Add(q, Request.QueryString[q]);
}
}
StructureHelper.Query(tableSlug, paramList, result);
ViewData.Model = result;
ViewBag.condition = paramList;
return(View());//TODO html editor, field mapping, validation for add and update
}
public ActionResult Create()
{
var msg = "";
ViewData.Model = StructureHelper.GetTableConfig(tableSlug);
if (Request.HttpMethod == "POST")
{
var form = Request.Form;
Dictionary <string, object> record = new Dictionary <string, object>();
foreach (var key in form.AllKeys)
{
record.Add(key, form[key]);
}
//TODO validation
StructureHelper.Create(tableSlug, record);
msg = "created";
}
ViewBag.msg = msg;
return(View());
}
public List <Node> BuildLevel(
int maxIterations,
int roomWidthMin,
int roomLengthMin,
int corridorWidth,
float bottomLeftPointModifier,
float topRightPointModifier,
int offset)
{
BinarySpacePartitioner bsp = new BinarySpacePartitioner(levelWidth, levelLength);
allNodesCollection = bsp.PrepareNodesCollection(maxIterations, roomWidthMin, roomLengthMin);
List <Node> roomSpaces = StructureHelper.TraverseGraphToExtractLowestLeaf(bsp.RootNode);
RoomGenerator roomGenerator = new RoomGenerator(maxIterations, roomLengthMin, roomWidthMin);
List <RoomNode> roomList = roomGenerator.GenerateRoomInGivenSpace(roomSpaces, bottomLeftPointModifier, topRightPointModifier, offset);
CorridorGenerator corridorGenerator = new CorridorGenerator();
List <Node> corridors = corridorGenerator.CreateCorridor(allNodesCollection, corridorWidth);
return(new List <Node>(roomList).Concat(corridors).ToList());
}
public void GenerateDoors(List <Node> corridors)
{
foreach (CorridorNode node in corridors)
{
if (node.connectedRooms[0] != null && node.connectedRooms[1] != null)
{
Vector2Int center = StructureHelper.CalculateMiddlePoint(node.BottomLeftCorner, node.TopRightCorner);
if (node.orientation == RelativePosition.Up || node.orientation == RelativePosition.Down)
{
GameObject newDoor = Instantiate(doorObject, new Vector3(center.x, 0, center.y), Quaternion.Euler(new Vector3(-90, 0, 0)));
node.connectedRooms[0].doors.Add(newDoor.transform);
node.connectedRooms[1].doors.Add(newDoor.transform);
}
else
{
GameObject newDoor = Instantiate(doorObject, new Vector3(center.x, 0, center.y), Quaternion.Euler(new Vector3(-90, 90, 0)));
node.connectedRooms[0].doors.Add(newDoor.transform);
node.connectedRooms[1].doors.Add(newDoor.transform);
}
}
}
}
private int GetXForNeighbor(Vector2Int bottomNodeLeft, Vector2Int bottomNodeRight, Vector2Int topNodeLeft, Vector2Int topNodeRight)
{
if (topNodeLeft.x < bottomNodeLeft.x && bottomNodeRight.x < topNodeRight.x)
{
return(StructureHelper.CalculateCenter(bottomNodeLeft + new Vector2Int(wallDistanceModifier, 0), bottomNodeRight - new Vector2Int(this.corridorWidth + wallDistanceModifier, 0)).x);
}
if (topNodeLeft.x >= bottomNodeLeft.x && bottomNodeRight.x >= topNodeRight.x)
{
return(StructureHelper.CalculateCenter(topNodeLeft + new Vector2Int(wallDistanceModifier, 0), topNodeRight - new Vector2Int(this.corridorWidth + wallDistanceModifier, 0)).x);
}
if (bottomNodeLeft.x >= topNodeLeft.x && bottomNodeLeft.x <= topNodeRight.x)
{
return(StructureHelper.CalculateCenter(bottomNodeLeft + new Vector2Int(wallDistanceModifier, 0), topNodeRight - new Vector2Int(this.corridorWidth + wallDistanceModifier, 0)).x);
}
if (bottomNodeRight.x <= topNodeRight.x && bottomNodeRight.x >= topNodeLeft.x)
{
return(StructureHelper.CalculateCenter(topNodeLeft + new Vector2Int(wallDistanceModifier, 0), bottomNodeRight - new Vector2Int(this.corridorWidth + wallDistanceModifier, 0)).x);
}
return(checkValue);
}
public ShellScreenObject(StructureHelper structureHelper) => StructureHelper = structureHelper;
public LoginScreenObject(StructureHelper structureHelper)
{
StructureHelper = structureHelper;
}
