private void CreatePassage(MazeCell cell, MazeCell otherCell, MazeDirection direction)
{
MazePassage prefab = Random.value < doorProbability ? doorPrefab : passagePrefab;
MazePassage passage = Instantiate(prefab) as MazePassage;
passage.Initialize(cell, otherCell, direction);
passage = Instantiate(prefab) as MazePassage;
if (passage is MazeDoor) {
otherCell.Initialize (CreateRoom (cell.room.settingsIndex));
} else {
otherCell.Initialize (cell.room);
}
passage.Initialize(otherCell, cell, direction.GetOpposite());
}
void CreatePassageInSameRoom(MazeCell cell, MazeCell otherCell, MazeDirection direction)
{
MazePassage passage = Instantiate(passagePrefab) as MazePassage;
passage.Initialize(cell, otherCell, direction);
passage = Instantiate(passagePrefab) as MazePassage;
passage.Initialize(otherCell, cell, direction.GetOpposite());
if (cell.room != otherCell.room)
{
MazeRoom roomToAssimilate = otherCell.room;
cell.room.Assimilate(roomToAssimilate);
rooms.Remove(roomToAssimilate);
Destroy(roomToAssimilate);
}
}
/// <summary>
/// Simply instantiate their respective prefabs and initialize them, once for both cells.
/// </summary>
/// <param name="mazeCell">Current cell point.</param>
/// <param name="otherMazeCell">Neighbour cell point.</param>
/// <param name="mazeDirection">Direction of the passage.</param>
private void CreatePassage(MazeCell mazeCell, MazeCell otherMazeCell, MazeDirection mazeDirection)
{
// Place a door or a passageway.
MazePassage prefab = Random.value < _mazeDoorProbability ? _mazeDoorPrefab : _mazePassagePrefab;
MazePassage passage = Instantiate(prefab);
passage.Initialize(mazeCell, otherMazeCell, mazeDirection);
passage = Instantiate(prefab);
// Check whether a door has been placed.
// If so, the other cell is the first of a new room.
// If not, it belongs to the same room as the previous cell.
otherMazeCell.Initialize(passage is MazeDoor ? CreateRoom(mazeCell.Room.IndexOfSettings) : mazeCell.Room);
passage.Initialize(otherMazeCell, mazeCell, mazeDirection.GetOpposite());
}
public void InitInfo(int _rMax, int _cMax)
{
rMax = _rMax;
cMax = _cMax;
roomInstance = GetComponent <MMRoomInstance>();
pathfinding = gameObject.AddComponent <APathfindingEdge>();
cells = new MazeCell[rMax, cMax];
EmptyPassage = new GameObject("EmptyPassage").AddComponent <MazePassage>();
EmptyWall = new GameObject("EmptyWall").AddComponent <MazeWall>();
EmptyWall.transform.parent = transform;
EmptyPassage.transform.parent = transform;
}
private void CreatePassage(MazeCell cell, MazeCell otherCell, MazeDirection direction)
{
MazePassage prefab = Random.Range(0.0f, 1.0f) < doorProbability ? doorPrefab : passagePrefab;
MazePassage passage = Instantiate(prefab) as MazePassage;
passage.BuildBetween(cell, otherCell, direction);
if (prefab is MazeDoor)
{
otherCell.InitWithRoom(CreateRoom(cell.room.settingsIndex));
}
else
{
otherCell.InitWithRoom(cell.room);
}
passage = Instantiate(prefab) as MazePassage;
passage.BuildBetween(otherCell, cell, direction.GetOpposite());
}
void CreatePassage(MazeCell thisCell, MazeCell thatCell, MazeDirection direction)
{
MazePassage prefab = Random.value < doorProbabilty ? doorPrefab : passagePrefab;
MazePassage passage = Instantiate(prefab) as MazePassage;
passage.Initialize(thisCell, thatCell, direction);
passage = Instantiate(prefab) as MazePassage;
if (passage is MazeDoor)
{
thatCell.Initialize(CreateRoom(thisCell.room.roomID));
}
else
{
thatCell.Initialize(thisCell.room);
}
passage.Initialize(thatCell, thisCell, direction.GetOposite());
}
private void CreatePassage(MazeCell parentCell, MazeCell neighbourCell, MazeDirection direction)
{
MazePassage prefab = Random.value < doorProbability ? doorPrefab : passagePrefab;
MazePassage passage = Instantiate(prefab);
passage.Initialize(parentCell, neighbourCell, direction);
passage = Instantiate(prefab);
if (passage is MazeDoor)
{
neighbourCell.Initialize(CreateRoom(parentCell.room.settingsIndex));
}
else
{
neighbourCell.Initialize(parentCell.room);
}
passage.Initialize(neighbourCell, parentCell, direction.GetOpposite());
}
/// <summary>
/// Creates the passage.
/// Passage has a Initialize on either side.
/// </summary>
/// <param name="currentCell">Current cell.</param>
/// <param name="neighbor">Neighbor.</param>
/// <param name="direction">Direction.</param>
void CreatePassage(MazeCell currentCell, MazeCell neighbor, MazeDirection direction)
{
MazePassage prefab = Random.value < mDoorProbability ? mDoorPrefab : mPassgaePrefab;
MazePassage passage = Instantiate(prefab) as MazePassage;
passage.Initialize(currentCell, neighbor, direction);
passage = Instantiate(prefab) as MazePassage;
if (passage is MazeDoor)
{
neighbor.Initialized(CreateRoom(currentCell.mRoom.mSettingsIndex));
mRoomCreatedTest += 1;
}
else
{
neighbor.Initialized(currentCell.mRoom);
}
passage.Initialize(neighbor, currentCell, direction.GetOpposite());
}
private void CreatePassage(MazeCell cell, MazeCell otherCell, MazeDirection direction)
{
//Debug.Log("CreatePassage " + cell.name + ", " + otherCell.name + ", " + direction.ToString());
MazePassage prefab = (Random.value < doorProbability) ? doorPrefab : passagePrefab; // 0.1 = 10%
MazePassage passage = Instantiate <MazePassage>(prefab);
passage.Initialize(cell, otherCell, direction);
passage = Instantiate <MazePassage>(prefab); // is 2nd needed? if yes then set pos.z = 0.475
if (passage is MazeDoor)
{
otherCell.Initialize(CreateRoom(cell.room.settingsIndex));
}
else
{
otherCell.Initialize(cell.room);
}
passage.Initialize(otherCell, cell, direction.GetOpposite());
}
private void CreatePassage(MazeCell cell, MazeCell otherCell, MazeDirection direction)
{
bool createDoor = randomGenerator.NextDouble() < DoorProbability;
if (createDoor)
{
MazePassage door = Instantiate(DoorPrefab) as MazePassage;
door.Initialize(cell, otherCell, direction);
MazePassage passage = Instantiate(PassagePrefab);
passage.Initialize(otherCell, cell, direction.GetOpposite());
otherCell.Initialize(CreateRoom(cell.Room.settingsIndex));
}
else
{
MazePassage passage = Instantiate(PassagePrefab) as MazePassage;
passage.Initialize(cell, otherCell, direction);
passage = Instantiate(PassagePrefab) as MazePassage;
otherCell.Initialize(cell.Room);
passage.Initialize(otherCell, cell, direction.GetOpposite());
}
}
void CreatePassage(MazeCell _cell, MazeCell _otherCell, mazeDirection _direction)
{
MazePassage prefabPass = Random.value < doorProbability ? mazeDoorPrefab : mazePassPrefab;
MazePassage mazePassage = Instantiate(prefabPass) as MazePassage;
mazePassage.Initialise(_cell, _otherCell, _direction);
if (mazePassage is MazeDoor)
{
//Create a new room, excluding the last index
_otherCell.SetRoom((CreateRoom(_cell.room.settingIndex)));
}
else
{
//initialize with the ongoing room
_otherCell.SetRoom(_cell.room);
}
mazePassage = Instantiate(prefabPass) as MazePassage;
mazePassage.Initialise(_otherCell, _cell, _direction.GetOpposite());
}
private void CreatePassage(MazeCell cell, MazeCell otherCell, MazeDirection direction)
{
bool createDecor = Random.value < cell.room.settings.decorProbability ? true : false;
if (otherCell.coordinates.x == playerCoordinates.x && otherCell.coordinates.z == playerCoordinates.z)
{
createDecor = false;
}
MazePassage prefab = Random.value < doorProbability ? doorPrefab[Random.Range(0, doorPrefab.Length)] : passagePrefab;
MazePassage passage = Instantiate(prefab, cell.transform.position, direction.ToRotation()) as MazePassage;
passage.Initialize(cell, otherCell, direction);
passage = Instantiate(prefab) as MazePassage;
if (passage is MazeDoor)
{
otherCell.Initialize(CreateRoom(cell.room.settingsIndex), false, useShaderMaterials);
}
else
{
otherCell.Initialize(cell.room, createDecor, useShaderMaterials);
}
passage.Initialize(otherCell, cell, direction.GetOpposite());
}
/// <summary>
/// Creates a passage between two cells, with no chance of a door.
/// </summary>
/// <param name="mazeCell">Current cell point.</param>
/// <param name="otherMazeCell">Neighbour cell point.</param>
/// <param name="direction">Direction of the passage.</param>
private void CreatePassageInSameRoom(MazeCell mazeCell, MazeCell otherMazeCell, MazeDirection direction)
{
// Declare variables.
MazePassage passage = Instantiate(_mazePassagePrefab);
// Initializing.
passage.Initialize(mazeCell, otherMazeCell, direction);
passage = Instantiate(_mazePassagePrefab);
passage.Initialize(otherMazeCell, mazeCell, direction.GetOpposite());
// Then we have Maze check whether it's connecting different rooms, in which case it assimilates and removes the
// other room.
if (mazeCell.Room == otherMazeCell.Room)
{
return;
}
MazeRoom roomToAssimilate = otherMazeCell.Room;
mazeCell.Room.Assimilate(roomToAssimilate);
_rooms.Remove(roomToAssimilate);
Destroy(roomToAssimilate);
}
// generate the puzzle rooms
private void CreatePuzzleRoom()
{
// go through puzzle room candidates, different sized rooms can hold different puzzles
// first cull small rooms from the list
for (int r = 0; r < rooms.Count; r++)
{
if (rooms[r].getCells().Count > 30 && rooms[r].getCells().Count < 50)
{
puzzleRooms.Add(rooms[r]);
}
}
// make sure there are only 3 puzzle rooms
int num = puzzleRooms.Count;
if (puzzleRooms.Count > 3)
{
for (int r = 0; r < num - 3; r++)
{
puzzleRooms.RemoveAt(puzzleRooms.Count - 1);
}
}
// change the floor material for the rooms
for (int r = 0; r < puzzleRooms.Count; r++)
{
puzzleRooms[r].roomSettings = roomSettings[roomSettings.Length - 1];
for (int c = 0; c < puzzleRooms[r].getCells().Count; c++)
{
puzzleRooms[r].getCells()[c].updateMaterial(puzzleRooms[r]);
}
}
// for each arch check if it connects a normal room with a puzzle room
GameObject[] archList = GameObject.FindGameObjectsWithTag("ArchObject");
for (int a = 0; a < archList.Length; a++)
{
// add a door
MazeArch arch = archList[a].GetComponent <MazeArch>();
MazeCell cellOne;
MazeCell cellTwo;
MazeDirection dir;
// if it does, then replace it with a door
if (arch.cell.room.roomSettings.floorMaterial == roomSettings[roomSettings.Length - 1].floorMaterial)
{
if (PhotonNetwork.isMasterClient)
{
cellOne = arch.cell;
cellTwo = arch.otherCell;
dir = arch.direction;
//MazePassage prefabType = doorPrefab;
//MazePassage passage = Instantiate(prefabType) as MazePassage;
//passage.Initialize(cellOne, cellTwo, dir);
GameObject newDoor;
Vector3 doorPos = new Vector3(0, 0, 0);
Quaternion doorRot = new Quaternion(0f, 0f, 0f, 0f);
newDoor = (GameObject)PhotonNetwork.InstantiateSceneObject("Door", doorPos, doorRot, 0);
MazePassage passage = newDoor.GetComponent <MazePassage>();
passage.Initialize(cellOne, cellTwo, dir);
}
}
}
}
// make two cells have passages towards each other
private void CreatePassage(MazeCell firstCell, MazeCell secondCell, MazeDirection direction)
{
// use perlin noise to calculate where arches should be
float generatedNoise = Mathf.PerlinNoise((firstCell.coordinates.x * secondCell.coordinates.x) / (float)mazeGenerationNumber, (firstCell.coordinates.z * secondCell.coordinates.z) / (float)mazeGenerationNumber);
MazePassage prefabType;
if (generatedNoise < 0.2)
{
prefabType = archPrefab;
}
else
{
prefabType = passagePrefab;
}
// instantiate it once for each cell
MazePassage passage = Instantiate(prefabType) as MazePassage;
passage.Initialize(firstCell, secondCell, direction);
passage = Instantiate(prefabType) as MazePassage;
// create passage between two rooms
if (passage is MazeArch)
{
secondCell.Initialize(CreateRoom(firstCell.room.settingsIndex));
}
else
{
secondCell.Initialize(firstCell.room);
}
passage.Initialize(secondCell, firstCell, direction.GetOpposite());
/*GameObject newPassage;
* Vector3 newPassagePos = new Vector3(0, 0, 0);
* Quaternion newPassageRot = new Quaternion(0f, 0f, 0f, 0f);
* if (generatedNoise < 0.2){
* newPassage = (GameObject) PhotonNetwork.Instantiate("Archway", newPassagePos, newPassageRot, 0);
* }
* else{
* newPassage = (GameObject) PhotonNetwork.Instantiate("MazePassage", newPassagePos, newPassageRot, 0);
* }
* MazePassage passage = newPassage.GetComponent<MazePassage>();
* passage.Initialize(firstCell, secondCell, direction);
*
* if (generatedNoise < 0.2){
* newPassage = (GameObject) PhotonNetwork.Instantiate("Archway", newPassagePos, newPassageRot, 0);
* }
* else{
* newPassage = (GameObject) PhotonNetwork.Instantiate("MazePassage", newPassagePos, newPassageRot, 0);
* }
*
* passage = newPassage.GetComponent<MazePassage>();
* // create passage between two rooms
* if (passage is MazeArch){
* secondCell.Initialize(CreateRoom(firstCell.room.settingsIndex));
* }
* else{
* secondCell.Initialize(firstCell.room);
* }
*
* passage.Initialize(secondCell, firstCell, direction.GetOpposite());*/
}
private void DifferentRoomAction (MazeCell cell, MazeCell otherCell, MazePassage passage) {
if (passage is MazeDoor)
otherCell.Initialize (CreateRoom (cell.room.settingsIndex));
else
otherCell.Initialize (cell.room);
}
// // 20cc : 23
private void CreatePassageInSameRoom(MazeCell cell, MazeCell otherCell, MazeDirection direction)
{
MazePassage passage = Instantiate(passagePrefab) as MazePassage;
passage.Initialize(cell, otherCell, direction);
}
private void CreatePassage(
List <MazeCell> activeCells,
MazeCell cell,
MazeCell otherCell,
MazeDirection direction)
{ // Create one of the possible passable edges from one a cell in one
// room to a cell in another.
MazePassage prefab = passagePrefab; // generic passage
if (cell.altitude == 0 &&
Random.value < doorProbability)
{
// Possibly make a door from one room to the next
prefab = doorPrefab;
if (Random.value < doorProbability &&
CanCreateStairs(cell, otherCell, direction))
{
// Instead of a door, let's try to make stairs. Stiars occupy
// both cell and other cell and enforce constraints on
// a low landing cell at the base of the stairs and a
// high landing cell at the top of the stairs.
prefab = passagePrefab; // Not a door after all!
cell.accessory = Instantiate(stairsPrefab) as MazeCellAccessory;
cell.accessory.cell = cell;
cell.accessory.transform.parent = cell.transform;
cell.accessory.transform.localPosition = Vector3.zero;
cell.accessory.transform.localRotation = direction.ToRotation();
otherCell.Initialize(cell.GetRoomNumber());
IntVector2 highLandingCoordinates = otherCell.coordinates +
direction.ToIntVector2();
MazeCell highLandingCell = CreateCell(
highLandingCoordinates, 1, cellPrefab);
activeCells.Add(highLandingCell);
highLandingCell.Initialize(otherCell.GetRoomNumber() + 1);
MazePassage landingPassage = Instantiate(prefab) as MazePassage;
landingPassage.Initialize(otherCell, highLandingCell, direction);
GameObject newColumn = Instantiate(columnPrefab) as GameObject;
newColumn.transform.parent = otherCell.transform;
newColumn.transform.localPosition = Vector3.zero;
newColumn.transform.localRotation = direction.ToRotation();
if (null != railingColumnPrefab)
{
GameObject newRailingColumn = Instantiate(railingColumnPrefab) as GameObject;
newRailingColumn.transform.parent = highLandingCell.transform;
newRailingColumn.transform.localPosition = Vector3.zero;
newRailingColumn.transform.localRotation = direction.ToRotation();
}
}
else
{
// Doors alsways change room numbers
otherCell.Initialize(cell.GetRoomNumber() + 1);
}
}
else
{
// This passage is neither door nor stair
otherCell.Initialize(cell.GetRoomNumber());
otherCell.altitude = cell.altitude;
otherCell.transform.localPosition = new Vector3(otherCell.transform.localPosition.x,
otherCell.transform.localPosition.y + otherCell.altitude * 1.078f,
otherCell.transform.localPosition.z);
}
MazePassage passage = Instantiate(prefab) as MazePassage;
passage.Initialize(cell, otherCell, direction);
}
