private void CreateWall(MuseumCell cell, MuseumCell otherCell, CellDirection direction)
{
bool hasPainting = Random.value < paintingDensity;
MuseumWall wall = Instantiate(wallPrefab) as MuseumWall;
wall.Initialize(cell, otherCell, direction);
if (otherCell != null)
{
wall = Instantiate(wallPrefab) as MuseumWall;
wall.Initialize(otherCell, cell, direction.GetOpposite());
}
if (hasPainting)
{
Painting painting = Instantiate(paintingPrefab) as Painting;
painting.Initialize(cell, direction);
if (paintings.Length > 0)
{
string paintingName = paintings[(int)Random.Range(0, paintings.Length)];
painting.LoadTexture(paintingName);
}
}
}
private void CreatePassageInSameRoom(MuseumCell cell, MuseumCell otherCell, CellDirection direction)
{
MuseumRoom room = cell.room;
bool isDisplayCase = Random.value < displayCaseProbability;
if (isDisplayCase)
{
MuseumDisplayCase displayCase = Instantiate(displayCasePrefab) as MuseumDisplayCase;
displayCase.Initialize(cell, otherCell, direction);
displayCase = Instantiate(displayCasePrefab) as MuseumDisplayCase;
displayCase.Initialize(otherCell, cell, direction.GetOpposite());
if (paintings.Length > 0)
{
string paintingName = paintings[(int)Random.Range(0, paintings.Length)];
displayCase.LoadTexture(paintingName);
}
}
else
{
MuseumPassage passage = Instantiate(passagePrefab) as MuseumPassage;
passage.Initialize(cell, otherCell, direction);
passage = Instantiate(passagePrefab) as MuseumPassage;
passage.Initialize(otherCell, cell, direction.GetOpposite());
}
}
public IEnumerator GenerateBTA()
{
DateTime startTime = DateTime.Now;
for (int x = 0; x < width; x++)
{
for (int z = 0; z < height; z++)
{
// print(String.Format("x: {0}, z: {1}", x, z));
CellLocation current_location = new CellLocation(x, z);
Cell currentCell = PlaceCell(current_location);
if (x == 0 && z == 0)
{
currentCell.Material = entryCellMaterial;
entryCell = currentCell;
}
else if (x == height - 1 && z == width - 1)
{
currentCell.Material = exitCellMaterial;
CellDirection exitCellDirection = GetDirectionThatLeadstoOutOfBound(currentCell);
currentCell.AddConnection(exitCellDirection);
exitCell = currentCell;
}
List <int> validDirections = new List <int>();
if (x > 0)
{
validDirections.Add(2);
}
if (z > 0)
{
validDirections.Add(1);
}
if (validDirections.Count > 0)
{
validDirections.Shuffle();
CellDirection selectedDirection = (CellDirection)validDirections[0];
CellLocation neighbourLocation = currentCell.Location + selectedDirection.ToRelativeCellLocation();
// print(String.Format("nx: {0}, nz: {1}", neighbourLocation.x, neighbourLocation.z));
CellDirection fromDirection = selectedDirection.GetOpposite();
currentCell.AddConnection(selectedDirection);
cells[neighbourLocation.x, neighbourLocation.z].AddConnection(fromDirection);
}
currentLength++;
cellDistances[currentCell.Location.x, currentCell.Location.z] = currentLength;
activeCells.Add(currentCell);
yield return(new WaitForSeconds(delay));
}
}
CreateCellWalls();
DateTime endTime = DateTime.Now;
String totalTime = endTime.Subtract(startTime).ToString();
print("Total time taken: " + totalTime);
print("Generate complete");
}
/// <summary>
/// This function does the actual pairing of two cells. This function is required separately for the wrapped coordinate system,
/// since there the two coordinates and the direction don't have a direct connection.
/// </summary>
/// <param name="currentCoordinates">This cells coordinates.</param>
/// <param name="neighborCoordinates">The neighboring cell's coordinates.</param>
/// <param name="toNeighbor">The direction towards the neighboring cell.</param>
void PairCells(Vector2 currentCoordinates, Vector2 neighborCoordinates, CellDirection toNeighbor)
{
//Debug.Log(currentCoordinates);
//Debug.Log(neighborCoordinates);
GetCell(currentCoordinates).AddNeighbor(toNeighbor, GetCell(neighborCoordinates));
GetCell(neighborCoordinates).AddNeighbor(toNeighbor.Opposite(), GetCell(currentCoordinates));
}
public Cell MakeConnection(Cell currentCell)
{
List <int> randomizedCellDirections = CellDirections.GetRandomizedCellDirections; // e.g [2, 1, 0, 3]
for (int i = 0; i < randomizedCellDirections.Count; i++)
{
// The random direction from the current cell
CellDirection direction = (CellDirection)randomizedCellDirections[i];
// The neighbor cell location from the direction
CellLocation nextLocation = currentCell.Location + direction.ToRelativeCellLocation();
if (CanPlaceCell(nextLocation))
{
CellDirection fromDirection = direction.GetOpposite();
Cell nextCell = PlaceCell(nextLocation, fromDirection);
currentCell.AddConnection(direction); // Direction that connects it to the newly generated cell
currentCell.name += "_" + direction;
return(nextCell);
}
}
return(null);
}
public static Vector2 Offset(CellDirection direction)
{
if (direction == CellDirection.N)
{
return(new Vector2(0, 1));
}
else if (direction == CellDirection.NE)
{
return(new Vector2(1, 1));
}
else if (direction == CellDirection.E)
{
return(new Vector2(1, 0));
}
else if (direction == CellDirection.SE)
{
return(new Vector2(1, -1));
}
else if (direction == CellDirection.S)
{
return(new Vector2(0, -1));
}
else if (direction == CellDirection.SW)
{
return(new Vector2(-1, -1));
}
else if (direction == CellDirection.W)
{
return(new Vector2(-1, 0));
}
else
{
return(new Vector2(-1, 1));
}
}
public override void Modify(CellDirection cellDir)
{
var sameDirOppLines = state.OppLines.Filter(cellDir.AnalyzedCell, cellDir.Direction).ToList();
if (!sameDirOppLines.Any())
{
return;
}
if (sameDirOppLines.Count >= 2 && sameDirOppLines.All(l => l.IsCellMiddle(cellDir.Cell)))
{
SplitCase(cellDir, sameDirOppLines);
return;
}
foreach (var sameDirOppLine in sameDirOppLines)
{
if (sameDirOppLine.IsCellMiddle(cellDir.Cell))
{
SplitCase(cellDir, new List <Line> {
sameDirOppLine
});
}
else
{
sameDirOppLine.CalcPropsAndEstimate(state.Board);
}
}
}
public Cell PlaceCell(CellLocation location, CellDirection fromDirection)
{
Cell cell = PlaceCell(location);
cell.AddConnection(fromDirection);
return(cell);
}
public override void Modify(CellDirection cellDir)
{
var sameDirLines = state.MyLines.Filter(cellDir.AnalyzedCell, cellDir.Direction).ToList();
var mirrorDirLines = state.MyLines.Filter(mirrorCellDir.AnalyzedCell, mirrorCellDir.Direction).ToList();
var intersect = sameDirLines.Intersect(mirrorDirLines).ToList();
foreach (var intersectedLine in intersect)
{
intersectedLine.AddMiddleCell(cellDir.Cell);
}
var sameDirLine = sameDirLines.Except(intersect).FirstOrDefault();
var mirrorDirLine = mirrorDirLines.Except(intersect).FirstOrDefault();
var isStrangeLongBrokenThree = StrangeLongBrokenThree(cellDir);
if (isStrangeLongBrokenThree)
{
AddMyLine(CreateMaxCellLine(cellDir.Swap()));
RemoveOneCellLine(sameDirLine);
RemoveOneCellLine(mirrorDirLine);
}
var shouldNotAddLine = intersect.Any() || isStrangeLongBrokenThree;
ProcessSide(cellDir, sameDirLine, shouldNotAddLine);
ProcessSide(mirrorCellDir, mirrorDirLine, shouldNotAddLine);
}
protected Line CreateMaxCellLine(CellDirection cellDir)
{
//create line with maximum possible number of cells. Distance <= 4 | X X*| X X*| X X *| XX XX*|
var cells = new List <Cell> {
cellDir.AnalyzedCell
};
var line = new Line(cells, state.MyCellType);
var dist = 1;
for (int i = cellDir.Distance + 1; i <= 4; i++)
{
var cell = cellDir.Analyzed(i);
if (cell.IsEmptyWithBoard(state.Board))
{
dist++;
}
if (cell.IsType(state.Board, state.OpponentCellType))
{
break;
}
if (cell.IsType(state.Board, state.MyCellType))
{
var tmpCellDir = new CellDirection(cell, cellDir.MirrorDirection, dist);
line.AddOuterCell(tmpCellDir);
dist = 1;
}
}
line.AddOuterCellAndEstimate(state.Board, cellDir);
return(line);
}
private void CreatePassage (MapCell cell, MapCell otherCell, CellDirection direction) {
if(cell == null) return;
Passage passage = Instantiate(passagePrefab) as Passage;
passage.Initialize(cell, otherCell, direction);
passage = Instantiate(passagePrefab) as Passage;
passage.Initialize(otherCell, cell, direction.GetOpposite());
}
public void Initialize(MuseumCell cell, CellDirection direction)
{
this.cell = cell;
this.direction = direction;
transform.parent = cell.transform;
transform.localPosition = Vector3.zero;
transform.localRotation = direction.ToRotation();
}
public void AddNeighbor(CellDirection direction, Cell cell)
{
// If the cell is valid and not yet in the neighbor dictionary, then add it.
if (cell != null && !neighbors.ContainsKey(direction))
{
neighbors.Add(direction, cell);
}
}
private void SetExitCell(Cell cell)
{
cell.Material = exitCellMaterial;
CellDirection exitCellDirection = GetDirectionThatLeadstoOutOfBound(cell);
cell.AddConnection(exitCellDirection);
exitCell = cell;
}
public void RemoveConnection(CellDirection direction)
{
if (connections[direction] != null)
{
Destroy(edges[direction].gameObject);
connections[direction] = null;
}
}
public void Initialize (MapCell cell, MapCell otherCell, CellDirection direction) {
this.cell = cell;
this.otherCell = otherCell;
this.direction = direction;
cell.SetEdge(direction, this);
transform.parent = cell.transform;
transform.localPosition = Vector3.zero;
transform.localRotation = direction.ToRotation();
}
public void NotSetNextCellReturnsNullTest(CellDirection direction)
{
var baseCell = new GridCell('A');
// no next cells set
var result = baseCell.GetNextCell(direction);
result.Should().BeNull();
}
public Transform CreateWall(CellDirection direction)
{
Transform wall = Instantiate(wallPrefab);
wall.transform.parent = transform;
wall.localPosition = Vector3.zero;
wall.localRotation = direction.ToRotation();
return(wall);
}
public void CanStringBeAssignedToGridTest(string populateText, int startRow, int startColumn,
string desiredString, CellDirection direction, bool expectedCanBeAssigned)
{
var grid = new StringSearchGrid(populateText);
var startCell = grid.GetCell(startRow, startColumn);
var canBeAssignedResult = startCell.CanBeAssigned(desiredString, direction);
canBeAssignedResult.Should().Be(expectedCanBeAssigned);
}
private static IEnumerable <int> findAffectedCells(int cell, CellDirection dir)
{
var x = cell % 9;
var y = cell / 9;
for (; inRange(x) && inRange(y); x += dx(dir), y += dy(dir))
{
yield return(x + 9 * y);
}
}
private void SplitCase(CellDirection cellDir, List <Line> sameDirOppLines)
{
skipDirections.Add(cellDir.MirrorDirection);
foreach (var sameDirOppLine in sameDirOppLines)
{
state.OppLines.Remove(sameDirOppLine);
}
AddOpponentLine(GetMaxLine(cellDir.AnalyzedCell, cellDir.Direction));
AddOpponentLine(GetMaxLine(cellDir.Cell + cellDir.MirrorDirection, cellDir.MirrorDirection));
}
public void AddConnection(CellDirection direction)
{
Transform connection = Instantiate(connectionPrefab);
connection.transform.parent = transform;
connection.localPosition = Vector3.zero;
connection.localRotation = direction.ToRotation();
connection.gameObject.SetActive(pathVisible);
connections[direction] = connection;
}
bool RequestForMovement(CellDirection cellDirection)
{
var neighbor = currentCell.GetOrSetNeighbor(cellDirection);
if (neighbor != null)
{
neighbor.IsClickable = true;
neighbor.OnClicked.AddListener(MoveToCellManager);
}
return(neighbor != null);
}
public void SetNextCell(CellDirection direction, GridCell cell)
{
if (this.nextCells.ContainsKey(direction))
{
this.nextCells[direction] = cell;
}
else
{
this.nextCells.Add(direction, cell);
}
}
private void ProcessSide(CellDirection cellDir, Line line, bool shouldNotAddLine)
{
if (CanAddCell(line, cellDir))
{
line.AddOuterCellAndEstimate(state.Board, cellDir);
}
else if (!shouldNotAddLine)
{
AddMyLine(CreateMaxCellLine(cellDir));
}
}
public void SetGetNextCellTest(CellDirection direction)
{
var baseCell = new GridCell('A');
var nextCell = new GridCell('B');
baseCell.SetNextCell(direction, nextCell);
var result = baseCell.GetNextCell(direction);
result.Should().Be(nextCell);
result.Value.Should().Be('B');
}
/// <summary>
/// Get the oppposite of a given direction .
/// </summary>
/// <param name="direction">direction one wants the opposite of</param>
/// <returns>the opposite direction</returns>
public static CellDirection Opposite(this CellDirection direction)
{
// make sure to not overflow
if ((int)direction < 4)
{
return(direction + 4);
}
else
{
return(direction - 4);
}
}
public bool CanBeAssigned(string desiredString, CellDirection direction)
{
var cellSequence = this.GetSequence(direction, desiredString.Length).ToList();
if (cellSequence.Count < desiredString.Length)
{
return(false);
}
bool assignable = desiredString.Select((c, i) => cellSequence[i].CanBeAssigned(c)).All(a => a);
return(assignable);
}
private static IEnumerable <int> findAffectedCells(int cell, int gridWidth, int gridHeight, CellDirection direction)
{
var x = cell % 9;
var y = cell / 9;
while (x >= 0 && x < gridWidth && y >= 0 && y < gridHeight)
{
yield return(x + 9 * y);
x += direction switch { CellDirection.Left => - 1, CellDirection.Right => 1, _ => 0 };
y += direction switch { CellDirection.Up => - 1, CellDirection.Down => 1, _ => 0 };
}
}
public override void Modify(CellDirection cellDir)
{
var sameDirLine = state.MyLines.FilterFirstOrDefault(cellDir.AnalyzedCell, cellDir.Direction);
if (CanAddCell(sameDirLine, cellDir))
{
sameDirLine.AddOuterCellAndEstimate(state.Board, cellDir);
}
else
{
AddMyLine(CreateMaxCellLine(cellDir));
}
}
/// <summary>
/// This function will rotate a given direction in mathematical positive direction (Rechte-Hand Regel).
/// </summary>
/// <param name="direction">The initial direction.</param>
/// <param name="angle">The angle of rotation in 45° steps.</param>
/// <returns></returns>
public static CellDirection Rotated(this CellDirection direction, float angle)
{
CellDirection newDirection = direction - (int)(angle / 45.0f);
if ((int)newDirection < 0)
{
newDirection += 8;
}
else if ((int)newDirection > 7)
{
newDirection -= 8;
}
return(newDirection);
}
public CellManager GetOrSetNeighbor(CellDirection cellDirection)
{
var cellManager = GetNeighbor(cellDirection);
if (cellManager == null)
{
cellManager = CellsManager.GetNeighbor(this, cellDirection);
if (cellManager != null)
{
SetNeighbor(cellManager, cellDirection);
}
}
return(cellManager);
}
private void CreateWall (MapCell cell, MapCell otherCell, CellDirection direction) {
if(cell == null) return;
//create 2 walls
// cell.GetEdge(direction).dest();
Wall wall = Instantiate(wallPrefab) as Wall;
wall.Initialize(cell, otherCell, direction);
wall.transform.localPosition +=
new Vector3(0, 1, 0);
// wall.gameObject.layer = LayerMask.NameToLayer ("Obstacles");
if (otherCell != null) {
// otherCell.GetEdge(direction.GetOpposite()).dest();
wall = Instantiate(wallPrefab) as Wall;
wall.Initialize(otherCell, cell, direction.GetOpposite());
wall.transform.localPosition +=
new Vector3(0, 1, 0);
}
}
private void CreateDesk (MapCell cell, MapCell otherCell, CellDirection direction) {
if(cell == null) return;
Desk desk = Instantiate(deskPrefab) as Desk;
// desk.Initialize(cell, otherCell, direction);
desk.transform.localPosition =
cell.transform.localPosition+ new Vector3(0, 1,0);
cell.hasdesk = true;
desk.transform.parent = cell.transform;
if(!otherCell.hasdesk){
Colleague colleague = Instantiate(matePrefab) as Colleague;
colleague.transform.localRotation = direction.ToRotation();
colleague.transform.localPosition = cell.transform.localPosition+direction.ToVector3();
colleague.transform.parent = desk.transform;
}
}
private MapCell GetNeighbor(MapCell cell, CellDirection direction){
MapCell neighbor = null;
IntVector2 coordinates = cell.coordinates + direction.ToIntVector2();
if(CoordMakeSense(coordinates)) neighbor = GetCell(coordinates);
return neighbor;
}
public void SetEdge (CellDirection direction, CellEdge edge) {
edges[(int)direction] = edge;
}
public CellEdge GetEdge (CellDirection direction) {
return edges[(int)direction];
}
private void CreateEdge(MapCell cell, CellDirection direction, string wall, bool room){
MapCell neighbor = GetNeighbor(cell, direction);
if(wall == "1") CreateWall(cell, neighbor, direction);
if(wall == "2") CreateDesk(cell, neighbor, direction);
if(room){
cell.transform.GetChild(0).GetComponent<Renderer>().material = roomfloormat;
}
}
