public VirtualMap.DirectionType GetNextDirection(VirtualMap map, CellLocation location) { VirtualMap.DirectionType directionPicked = new VirtualMap.DirectionType(); //right if (directionsPicked.Count == 0) //nulla da fare { map.visitedAndBlockedCells.Add(location); return(VirtualMap.DirectionType.None); } else if (directionsPicked.Count == 1) //solo una ne ho, non c'e nbisogno di fare altro { directionPicked = directionsPicked[0]; } else if (directionsPicked.Contains(PreviousDirection)) //posso cambiare o meno { if (MustChangeDirection) //se sono qua ho almeno due direzioni, levo quella corrente, perche' un'altra ce ne deve essere { directionsPicked.Remove(PreviousDirection); int index = DungeonGenerator.Random.Instance.Next(0, directionsPicked.Count - 1); directionPicked = directionsPicked[index]; } else { directionPicked = PreviousDirection; } } else //devo cambiare per forza { int index = DungeonGenerator.Random.Instance.Next(0, directionsPicked.Count - 1); directionPicked = directionsPicked[index]; } return(directionPicked); }
public T GetPrefab(VirtualCell.CellType cell_type, VirtualMap.DirectionType orientation = VirtualMap.DirectionType.None) { S[] type_choices = null; type_choices = GetVariations(cell_type, orientation); if (type_choices == null) { return(default(T)); } // Get one with a weighted random int tot = 0; foreach (S choice in type_choices) { tot += choice.weight; } int rnd = DungeonGenerator.Random.Instance.Next(1, tot); // Debug.Log(cell_type + " " + tot + " " + rnd); int current = 0; foreach (S choice in type_choices) { current += choice.weight; if (rnd <= current) { // Debug.Log("YTYPE " + cell_type + " CHOICE: " + choice.choice); return(choice.choice); } } return(default(T)); }
override public void StartDigging(VirtualMap map, CellLocation starting_location, int directionChangeModifier) { CellLocation currentLocation = starting_location; map.MarkAsVisited(currentLocation); // Pick a starting previous direction VirtualMap.DirectionType previousDirection = VirtualMap.DirectionType.North; List <CellLocation> previousLocations = new List <CellLocation>(); // Repeat until all cells have been visited while (!map.AllCellsVisited) { // Get a starting direction DirectionPicker directionPicker = new DirectionPicker(map, currentLocation, directionChangeModifier, previousDirection); VirtualMap.DirectionType direction = directionPicker.GetNextDirection(map, currentLocation); if (direction != VirtualMap.DirectionType.None) { // Create a corridor in the current cell and flag it as visited previousLocations.Add(currentLocation); previousDirection = direction; currentLocation = map.CreateCorridor(currentLocation, direction); map.FlagCellAsVisited(currentLocation); } else { // Backtrack currentLocation = previousLocations[previousLocations.Count - 1]; previousLocations.RemoveAt(previousLocations.Count - 1); } } }
virtual protected T GetDefault(string defaultName, VirtualMap.DirectionType orientation) { T default_object = Resources.Load(defaultName, typeof(T)) as T; //if (default_object == null) Debug.LogWarning ("No default for type " + defaultName + " could be found! Make sure to add a variation for it!"); DaedalusDebugUtils.Assert(default_object != null, "No default of name " + defaultName + " could be found!", this); return(default_object); }
// Get target starting_location from a valid cell/direction public CellLocation GetTargetLocation(CellLocation location, VirtualMap.DirectionType direction) { if (!HasAdjacentCellInDirection(location, direction)) { return(new CellLocation(-1, -1)); } else { return(GetNeighbourCellLocationOfSameType(location, direction)); } }
public DirectionPicker(VirtualMap map, CellLocation location, int changeDirectionModifier, VirtualMap.DirectionType previousDirection) { this.PreviousDirection = previousDirection; this.PreviousLocation = location; this.ChangeDirectionModifier = changeDirectionModifier; foreach (VirtualMap.DirectionType dir in map.directions) { if (map.HasAdjacentCellInDirection(location, dir) && !map.AdjacentCellInDirectionIsVisited(location, dir)) { directionsPicked.Add(dir); } } }
// Override the constructor for opening dead ends public DirectionPicker(VirtualMap map, CellLocation location, VirtualMap.DirectionType previousDirection) { this.PreviousDirection = previousDirection; this.PreviousLocation = location; this.ChangeDirectionModifier = 100; // Always change the direction foreach (VirtualMap.DirectionType dir in map.directions) { if (map.HasAdjacentCellInDirection(location, dir) && (LINK_DEAD_ENDS_PASSING_ON_ROCKS || !map.AdjacentCellInDirectionIsRock(location, dir))) { directionsPicked.Add(dir); } } }
override protected SpriteChoice[] GetVariations(VirtualCell.CellType cell_type, VirtualMap.DirectionType orientation = VirtualMap.DirectionType.None) { SpriteChoice[] type_choices = null; switch (cell_type) { case VirtualCell.CellType.Fake3D_Corridor_WallAbove: type_choices = fake3DCorridorWallAbove; break; case VirtualCell.CellType.Fake3D_Corridor_WallFront: type_choices = fake3DCorridorWallFront; break; case VirtualCell.CellType.Fake3D_Room_WallAbove: type_choices = fake3DRoomWallAbove; break; case VirtualCell.CellType.Fake3D_Room_WallFront: type_choices = fake3DRoomWallFront; break; // case VirtualCell.CellType.DoorHorizontalTop: type_choices = doorsHorizontalTop; break; case VirtualCell.CellType.DoorHorizontalBottom: type_choices = doorsHorizontalBottom; break; case VirtualCell.CellType.DoorVertical: type_choices = doorsVertical; break; default: type_choices = base.GetVariations(cell_type, orientation); break; } return(type_choices); }
// Open dead ends by linking them to rooms private void OpenDeadEnds(VirtualMap map) { // Console.WriteLine("DEAD END MOD: " + openDeadEndModifier); if (openDeadEndModifier == 0) { return; } IEnumerable <CellLocation> deads = map.DeadEndCellLocations; foreach (CellLocation deadEnd in deads) { if (DungeonGenerator.Random.Instance.Next(1, 99) < openDeadEndModifier) { CellLocation currentLocation = deadEnd; // int count=0; do { // Initialize the direction picker not to select the dead-end corridor direction DirectionPicker directionPicker = new DirectionPicker(map, currentLocation, map.CalculateDeadEndCorridorDirection(currentLocation)); // Debug.Log("We have a dead and " + directionPicker); VirtualMap.DirectionType direction = directionPicker.GetNextDirection(map, currentLocation); // Debug.Log("We choose dir " + direction); if (direction == VirtualMap.DirectionType.None) { throw new InvalidOperationException("Could not remove the dead end!"); } // Debug.Log("Cannot go that way!"); else { // Create a corridor in the selected direction currentLocation = map.CreateCorridor(currentLocation, direction); } // count++; } while (map.IsDeadEnd(currentLocation) && currentLocation != deadEnd); // Stop when you intersect an existing corridor, or when you end back to the starting cell (that means we could not remove the dead end, happens with really small maps // Debug.Log("Dead end removed"); } } }
override public void StartDigging(VirtualMap map, CellLocation starting_location, int directionChangeModifier) { CellLocation currentLocation = starting_location; map.MarkAsVisited(currentLocation); // Pick a previous direction VirtualMap.DirectionType previousDirection = VirtualMap.DirectionType.North; // Repeat until all cells have been visited while (!map.AllCellsVisited) { // Get a starting direction DirectionPicker directionPicker = new DirectionPicker(map, currentLocation, directionChangeModifier, previousDirection); VirtualMap.DirectionType direction = directionPicker.GetNextDirection(map, currentLocation); if (direction != VirtualMap.DirectionType.None) { // Create a corridor in the current cell and flag it as visited currentLocation = map.CreateCorridor(currentLocation, direction); map.FlagCellAsVisited(currentLocation); previousDirection = direction; } // or start from another visited cell // NOTE: This may be less performant! else { currentLocation = map.GetRandomVisitedCell(currentLocation); // No visited cell available: proceed from a random unvisited cell if (currentLocation.x == -1) { currentLocation = map.PickRandomUnvisitedLocation(); map.MarkAsVisited(currentLocation); } } } }
override protected Sprite GetDefault(string defaultName, VirtualMap.DirectionType orientation = VirtualMap.DirectionType.None) { // Debug.Log (defaultName); DaedalusDebugUtils.Assert(loadedSpritesDict.ContainsKey(defaultName), "Cannot find default texture asset " + defaultName); return(loadedSpritesDict[defaultName]); }
// Control if we can open a door in the given direction. Open it if possible private bool CheckDoorCreation(VirtualMap map, VirtualRoom r, CellLocation start_floor_loc, VirtualMap.DirectionType direction) { bool result = false; CellLocation end_floor_loc = map.GetTargetLocation(start_floor_loc, direction); CellLocation passage = map.GetNeighbourCellLocation(start_floor_loc, direction); // We get the ending floor and check its validity if (end_floor_loc.isValid() && !map.GetCell(end_floor_loc).IsRock()) { // We check whether we are connecting to another room if (map.roomCells.Contains(end_floor_loc)) { // Check if we skip creating the door if (DungeonGenerator.Random.Instance.Next(0, 100) > doorsDensityModifier && // We do not skip if we request more doors than needed r.IsAlreadyConnectedToARoomAt(end_floor_loc, map)) // We skip if we are already connected { return(result); } OpenRoomDoor(map, r, start_floor_loc, end_floor_loc, passage, direction); } else { // We need one door for each corridor segment that has been separated out by this room // To do that, we also create a door if the ending floor is a dead end, effectively getting rid of the dead end // Also, we create if the ending floor is a rock (i.e. 4 walls), which can happen if this room blocks out single floor cells! // We check if we need to skip if (CheckSkipDoorToCorridor(map, r, end_floor_loc)) { return(result); } // Debug.Log("Room " + r + " CREATING TO " + passage); OpenCorridorDoor(map, r, start_floor_loc, end_floor_loc, passage, direction); } result = true; } return(result); }
/******************** * Door Creation NEW ********************/ public void OpenRoomDoor(VirtualMap map, VirtualRoom room, CellLocation start_floor_loc, CellLocation end_floor_loc, CellLocation passage_loc, VirtualMap.DirectionType direction) { //Debug.Log(room); // We update both this and the connected room foreach (VirtualRoom tr in map.rooms) { if (tr.containsLocation(end_floor_loc)) { tr.AddDoorToAnotherRoom(passage_loc); room.AddDoorToAnotherRoom(passage_loc); tr.ConnectRoom(room); room.ConnectRoom(tr); break; } } OpenDoor(map, start_floor_loc, end_floor_loc, passage_loc, direction); }
virtual protected S[] GetVariations(VirtualCell.CellType cell_type, VirtualMap.DirectionType orientation) { S[] type_choices = null; switch (cell_type) { case VirtualCell.CellType.CorridorWall: type_choices = corridorWallVariations; break; case VirtualCell.CellType.CorridorFloor: type_choices = corridorFloorVariations; break; case VirtualCell.CellType.CorridorColumn: type_choices = corridorColumnVariations; break; case VirtualCell.CellType.RoomWall: type_choices = roomWallVariations; break; case VirtualCell.CellType.RoomFloor: type_choices = roomFloorVariations; break; case VirtualCell.CellType.RoomColumn: type_choices = roomColumnVariations; break; case VirtualCell.CellType.InsideRoomColumn: type_choices = insideRoomColumnVariations; break; case VirtualCell.CellType.Door: type_choices = doorVariations; break; case VirtualCell.CellType.RoomDoor: type_choices = roomDoorVariations; break; case VirtualCell.CellType.PassageColumn: type_choices = passageColumnVariations; break; case VirtualCell.CellType.Rock: type_choices = rockVariations; break; case VirtualCell.CellType.CorridorFloorU: type_choices = corridorFloorUVariations; break; case VirtualCell.CellType.CorridorFloorI: type_choices = corridorFloorIVariations; break; case VirtualCell.CellType.CorridorFloorL: type_choices = corridorFloorLVariations; break; case VirtualCell.CellType.CorridorFloorT: type_choices = corridorFloorTVariations; break; case VirtualCell.CellType.CorridorFloorX: type_choices = corridorFloorXVariations; break; case VirtualCell.CellType.RoomFloorInside: type_choices = roomFloorInsideVariations; break; case VirtualCell.CellType.RoomFloorBorder: type_choices = roomFloorBorderVariations; break; case VirtualCell.CellType.RoomFloorCorner: type_choices = roomFloorCornerVariations; break; case VirtualCell.CellType.PerimeterWall: type_choices = perimeterWallVariations; break; case VirtualCell.CellType.PerimeterColumn: type_choices = perimeterColumnVariations; break; case VirtualCell.CellType.CorridorWallO: type_choices = corridorWallOVariations; break; case VirtualCell.CellType.CorridorWallU: type_choices = corridorWallUVariations; break; case VirtualCell.CellType.CorridorWallI: type_choices = corridorWallIVariations; break; case VirtualCell.CellType.CorridorWallL: type_choices = corridorWallLVariations; break; case VirtualCell.CellType.CorridorWallT: type_choices = corridorWallTVariations; break; case VirtualCell.CellType.CorridorWallX: type_choices = corridorWallXVariations; break; case VirtualCell.CellType.RoomWallO: type_choices = roomWallOVariations; break; case VirtualCell.CellType.RoomWallU: type_choices = roomWallUVariations; break; case VirtualCell.CellType.RoomWallI: type_choices = roomWallIVariations; break; case VirtualCell.CellType.RoomWallL: type_choices = roomWallLVariations; break; case VirtualCell.CellType.RoomWallT: type_choices = roomWallTVariations; break; case VirtualCell.CellType.RoomWallX: type_choices = roomWallXVariations; break; default: Debug.LogError("No prefab for cell type " + cell_type); break; } return(type_choices); }
protected void AddFillingFloors(VirtualMap map, VirtualCell conversion_cell) { if (conversion_cell.Type == VirtualCell.CellType.None) { return; } // Fill with floors VirtualCell.CellType initial_type = conversion_cell.Type; VirtualMap.DirectionType initial_dir = conversion_cell.Orientation; bool addedFloor = false; if (behaviour.fillWithFloors) { bool mayBeDirectional = false; if (CheckRoom(map, conversion_cell.location)) { if (conversion_cell.IsDoor() || conversion_cell.IsEmpty()) { AddToCorrectRoom(map, conversion_cell.location); conversion_cell.Type = VirtualCell.CellType.RoomFloor; ConvertDirectionalRoomFloor(map, conversion_cell); mayBeDirectional = true; } else { conversion_cell.Type = VirtualCell.CellType.RoomFloor; } } else { if (conversion_cell.IsDoor() || conversion_cell.IsEmpty()) { conversion_cell.Type = VirtualCell.CellType.CorridorFloor; ConvertDirectionalCorridorFloor(map, conversion_cell); mayBeDirectional = true; } else { conversion_cell.Type = VirtualCell.CellType.CorridorFloor; } } ConvertFloor(map, conversion_cell, mayBeDirectional); addedFloor = true; } else { // Special case: when not filling with floors AND we do not draw doors, we still need to place a floor underneath the empty passage representing the doors! if (conversion_cell.IsEmpty()) // Decomment this if you want floors underneath doors ALWAYS: // || input_cell.IsDoor()){ { conversion_cell.Type = VirtualCell.CellType.CorridorFloor; ConvertDirectionalCorridorFloor(map, conversion_cell); ConvertFloor(map, conversion_cell); addedFloor = true; } } if (addedFloor) { // The initial type is switched in, the floor becomes a subtype VirtualCell.CellType new_subtype = conversion_cell.Type; VirtualMap.DirectionType new_dir = conversion_cell.Orientation; conversion_cell.Type = initial_type; conversion_cell.Orientation = initial_dir; conversion_cell.AddCellInstance(new_subtype, new_dir); } }
public void OpenCorridorDoor(VirtualMap map, VirtualRoom room, CellLocation start_floor_loc, CellLocation end_floor_loc, CellLocation passage_loc, VirtualMap.DirectionType direction) { room.corridorExit++; room.corridorDoors.Add(passage_loc); OpenDoor(map, start_floor_loc, end_floor_loc, passage_loc, direction); }
public void OpenDoor(VirtualMap map, CellLocation start_floor_loc, CellLocation end_floor_loc, CellLocation passage_loc, VirtualMap.DirectionType direction) { map.GetCell(passage_loc).Type = VirtualCell.CellType.Door; map.GetCell(passage_loc).Orientation = direction; // We also connect the cells map.ConnectCells(start_floor_loc, end_floor_loc); }
override public void CreateObject(VirtualMap map, MetricLocation l, VirtualCell.CellType cell_type, VirtualMap.DirectionType orientation) { Texture2D tile_texture = null; tile_texture = behaviour.GetPrefab(cell_type); GameObject go = (GameObject)GameObject.Instantiate(behaviour.tilePrefab, new Vector3(l.x * behaviour.tileSize, 0, l.y * behaviour.tileSize), Quaternion.identity); var tempMaterial = new Material(go.transform.GetComponent <Renderer>().sharedMaterial); tempMaterial.SetTexture("_MainTex", tile_texture); tempMaterial.name = cell_type.ToString() + "_Material"; go.transform.GetComponent <Renderer>().sharedMaterial = tempMaterial; if (createdMaterialsList == null) { createdMaterialsList = new List <Material>(); } createdMaterialsList.Add(tempMaterial); go.name = cell_type.ToString(); AddToMapGameObject(cell_type, go); go.transform.localEulerAngles = new Vector3(0, 0, 0); switch (orientation) { case VirtualMap.DirectionType.West: go.transform.localEulerAngles = new Vector3(0, 0, 0); break; case VirtualMap.DirectionType.North: go.transform.localEulerAngles = new Vector3(0, 90, 0); break; case VirtualMap.DirectionType.East: go.transform.localEulerAngles = new Vector3(0, 180, 0); break; case VirtualMap.DirectionType.South: go.transform.localEulerAngles = new Vector3(0, 270, 0); break; } // Move walls up a bit if (VirtualCell.IsFloor(cell_type)) { // Already good } else { go.transform.localPosition += Vector3.up * 0.01f; } }
public void AddCellInstance(VirtualCell.CellType type, VirtualMap.DirectionType dir) { // TODO: Should we check if we add two times the same type? this.instances.Add(new CellInstance(type, dir)); }
override public void CreateObject(VirtualMap map, MetricLocation l, VirtualCell.CellType cell_type, VirtualMap.DirectionType orientation) { GameObject prefab = behaviour.GetPrefab(cell_type); DaedalusDebugUtils.Assert(prefab != null, "No variation was chosen for " + cell_type); // Debug.Log (cell_type); GameObject go = (GameObject)GameObject.Instantiate(prefab, new Vector3(l.x * behaviour.tileSize, l.storey * (behaviour.wallHeight + behaviour.storeySeparationHeight), l.y * behaviour.tileSize), Quaternion.identity); go.name = cell_type.ToString(); switch (orientation) { case VirtualMap.DirectionType.West: go.transform.localEulerAngles = new Vector3(0, 180, 0); break; case VirtualMap.DirectionType.North: go.transform.localEulerAngles = new Vector3(0, 270, 0); break; case VirtualMap.DirectionType.East: break; case VirtualMap.DirectionType.South: go.transform.localEulerAngles = new Vector3(0, 90, 0); break; } // Checking orientation and position for ceiling if (cell_type == VirtualCell.CellType.CorridorCeiling || cell_type == VirtualCell.CellType.RoomCeiling) { Vector3 tmpPos = go.transform.position; tmpPos.y += behaviour.wallHeight; go.transform.position = tmpPos; Vector3 tmpRot = go.transform.localEulerAngles; tmpRot.x = 180; go.transform.localEulerAngles = tmpRot; } bool isDynamicCell = GetIsDynamicCell(cell_type); AddToMapGameObject(cell_type, go, isDynamicCell, l.storey); }
override public void CreateObject(VirtualMap map, MetricLocation l, VirtualCell.CellType cell_type, VirtualMap.DirectionType orientation) { GameObject prefab = behaviour.GetPrefab(cell_type); DaedalusDebugUtils.Assert(prefab != null, "No variation was chosen for " + cell_type); GameObject go = (GameObject)GameObject.Instantiate(prefab, new Vector3(l.x * behaviour.tileSize, l.storey * (behaviour.wallHeight + behaviour.storeySeparationHeight), l.y * behaviour.tileSize), Quaternion.identity); go.name = cell_type.ToString(); if (orientation == VirtualMap.DirectionType.None) { orientation = VirtualMap.DirectionType.North; } switch (orientation) { case VirtualMap.DirectionType.West: go.transform.localEulerAngles = new Vector3(0, 180, 0); break; case VirtualMap.DirectionType.North: go.transform.localEulerAngles = new Vector3(0, 270, 0); break; case VirtualMap.DirectionType.East: go.transform.localEulerAngles = new Vector3(0, 0, 0); break; case VirtualMap.DirectionType.South: go.transform.localEulerAngles = new Vector3(0, 90, 0); break; } go.transform.localEulerAngles += new Vector3(0, 180, 0); // Orientation fix AddToMapGameObject(cell_type, go, cell_type == VirtualCell.CellType.Door, l.storey); }
// Create a corridor between one cell and another, digging the passage in-between. // This will make sure that the starting floor and the end floor become corridor floors, if they are ROCKS or NONEs public CellLocation CreateCorridor(CellLocation zero_starting_location, VirtualMap.DirectionType direction, int corridor_width = 1, bool makeDoor = false) { // NOTE: we do not drill room walls (unless we make doors) VirtualCell cell; CellLocation target_location = default(CellLocation); // CHECK whether there is enough corridor space (NOTE: this only works for corridor_width=2) while (LocationIsOutsideBounds(GetNeighbourCellLocationAtStep(zero_starting_location, GetDirectionClockwise(direction, 1), (2 * (corridor_width - 1))))) { Debug.LogWarning("Decreasing corridor width to due to out of bounds problems!"); corridor_width--; } for (int cw = 0; cw < corridor_width; cw++) { CellLocation starting_location = GetNeighbourCellLocationAtStep(zero_starting_location, GetDirectionClockwise(direction, 1), 2 * cw); // Starting cell = this.GetCell(starting_location); if (cell.IsRock() || cell.IsNone()) { cell.Type = VirtualCell.CellType.CorridorFloor; } // Target target_location = GetTargetLocation(starting_location, direction); cell = this.GetCell(target_location); //if (cell.IsFloor()) break; // NO! Already ! if (cell.IsRock() || cell.IsNone()) { cell.Type = VirtualCell.CellType.CorridorFloor; } // cell.Orientation = direction; // This is removed, because the directional tiles will take care of this instead // Connection passage CellLocation connection_location = GetNeighbourCellLocation(starting_location, direction); cell = this.GetCell(connection_location); if (cell.Type == VirtualCell.CellType.CorridorWall) { cell.Type = VirtualCell.CellType.EmptyPassage; ConnectCells(starting_location, target_location); } else if (cell.Type == VirtualCell.CellType.RoomWall && makeDoor && CheckDoorCreation(cw, corridor_width)) { cell.Type = VirtualCell.CellType.Door; cell.Orientation = direction; // Force orientation for doors, or it will crash ConnectCells(starting_location, target_location); } // cell.Orientation = direction; // Setting this would just change randomly the direction of some walls in tilemaps. This is removed for now! // We also create walls around the digging, UNLESS there are already floors there (or out of bounds) (as we already have the walls) VirtualMap.DirectionType clockwise_dir = GetDirectionClockwise(direction, 1); VirtualMap.DirectionType counter_clockwise_dir = GetDirectionClockwise(direction, -1); CellLocation neigh_same_loc; // Sides back if (!IsInRoom(starting_location)) { if (cw == corridor_width - 1) { neigh_same_loc = this.GetNeighbourCellLocationOfSameType(starting_location, clockwise_dir); if (LocationIsOutsideBounds(neigh_same_loc) || this.GetCell(neigh_same_loc).Type != VirtualCell.CellType.CorridorFloor) { VirtualCell other_cell = this.GetCell(this.GetNeighbourCellLocation(starting_location, clockwise_dir)); if (other_cell.Type == VirtualCell.CellType.EmptyPassage) { other_cell.Type = VirtualCell.CellType.CorridorWall; } } } if (cw == 0) { neigh_same_loc = this.GetNeighbourCellLocationOfSameType(starting_location, counter_clockwise_dir); if (LocationIsOutsideBounds(neigh_same_loc) || this.GetCell(neigh_same_loc).Type != VirtualCell.CellType.CorridorFloor) { VirtualCell other_cell = this.GetCell(this.GetNeighbourCellLocation(starting_location, counter_clockwise_dir)); if (other_cell.Type == VirtualCell.CellType.EmptyPassage) { other_cell.Type = VirtualCell.CellType.CorridorWall; } } } } // Sides front if (!IsInRoom(target_location)) { if (cw == corridor_width - 1) { neigh_same_loc = this.GetNeighbourCellLocationOfSameType(target_location, clockwise_dir); if (LocationIsOutsideBounds(neigh_same_loc) || this.GetCell(neigh_same_loc).Type != VirtualCell.CellType.CorridorFloor) { VirtualCell other_cell = this.GetCell(this.GetNeighbourCellLocation(target_location, clockwise_dir)); if (other_cell.Type == VirtualCell.CellType.EmptyPassage) { other_cell.Type = VirtualCell.CellType.CorridorWall; } } } if (cw == 0) { neigh_same_loc = this.GetNeighbourCellLocationOfSameType(target_location, counter_clockwise_dir); if (LocationIsOutsideBounds(neigh_same_loc) || this.GetCell(neigh_same_loc).Type != VirtualCell.CellType.CorridorFloor) { VirtualCell other_cell = this.GetCell(this.GetNeighbourCellLocation(target_location, counter_clockwise_dir)); if (other_cell.Type == VirtualCell.CellType.EmptyPassage) { other_cell.Type = VirtualCell.CellType.CorridorWall; } } } } // Back if (!IsInRoom(starting_location)) { neigh_same_loc = this.GetNeighbourCellLocationOfSameType(starting_location, GetDirectionOpposite(direction)); if (LocationIsOutsideBounds(neigh_same_loc) || this.GetCell(neigh_same_loc).Type != VirtualCell.CellType.CorridorFloor) { VirtualCell other_cell = this.GetCell(this.GetNeighbourCellLocation(starting_location, GetDirectionOpposite(direction))); if (other_cell.Type == VirtualCell.CellType.EmptyPassage) { other_cell.Type = VirtualCell.CellType.CorridorWall; } } } // Front if (!IsInRoom(target_location)) { neigh_same_loc = this.GetNeighbourCellLocationOfSameType(target_location, direction); if (LocationIsOutsideBounds(neigh_same_loc) || this.GetCell(neigh_same_loc).Type != VirtualCell.CellType.CorridorFloor) { VirtualCell other_cell = this.GetCell(this.GetNeighbourCellLocation(target_location, direction)); if (other_cell.Type == VirtualCell.CellType.EmptyPassage) { other_cell.Type = VirtualCell.CellType.CorridorWall; } } } } return(target_location); }
protected void BuildObject(VirtualMap map, CellLocation loc, int storey, VirtualCell.CellType type, VirtualMap.DirectionType dir) { if (type == VirtualCell.CellType.None || type == VirtualCell.CellType.EmptyPassage) { return; // TODO: Maybe this check should be in the physical map } // Debug.Log (loc + " " + type); MetricLocation metricLocation = GetWorldLocation(loc, storey); physical_map.CreateObject(map, metricLocation, type, dir); }
override protected GameObjectChoice[] GetVariations(VirtualCell.CellType cell_type, VirtualMap.DirectionType orientation = VirtualMap.DirectionType.None) { if (orientation == VirtualMap.DirectionType.None) { orientation = VirtualMap.DirectionType.North; } // Treats floors as prefab sections GameObjectChoice[] type_choices = null; switch (cell_type) { case VirtualCell.CellType.CorridorFloorU: switch (orientation) { case VirtualMap.DirectionType.East: type_choices = sectionUVariations_E; break; case VirtualMap.DirectionType.North: type_choices = sectionUVariations_N; break; case VirtualMap.DirectionType.West: type_choices = sectionUVariations_W; break; case VirtualMap.DirectionType.South: type_choices = sectionUVariations_S; break; } break; case VirtualCell.CellType.CorridorFloorI: switch (orientation) { case VirtualMap.DirectionType.East: type_choices = sectionIVariations_WE; break; case VirtualMap.DirectionType.North: type_choices = sectionIVariations_NS; break; case VirtualMap.DirectionType.West: type_choices = sectionIVariations_WE; break; case VirtualMap.DirectionType.South: type_choices = sectionIVariations_NS; break; } break; case VirtualCell.CellType.CorridorFloorL: switch (orientation) { case VirtualMap.DirectionType.East: type_choices = sectionLVariations_SE; break; case VirtualMap.DirectionType.North: type_choices = sectionLVariations_NE; break; case VirtualMap.DirectionType.West: type_choices = sectionLVariations_NW; break; case VirtualMap.DirectionType.South: type_choices = sectionLVariations_SW; break; } break; case VirtualCell.CellType.CorridorFloorT: switch (orientation) { case VirtualMap.DirectionType.East: type_choices = sectionTVariations_XE; break; case VirtualMap.DirectionType.North: type_choices = sectionTVariations_XN; break; case VirtualMap.DirectionType.West: type_choices = sectionTVariations_XW; break; case VirtualMap.DirectionType.South: type_choices = sectionTVariations_XS; break; } break; case VirtualCell.CellType.CorridorFloorX: type_choices = sectionXVariations; break; default: type_choices = base.GetVariations(cell_type, orientation); break; } return(type_choices); }
override public void CreateObject(VirtualMap map, MetricLocation l, VirtualCell.CellType cell_type, VirtualMap.DirectionType orientation) { GameObject prefab = behaviour.GetPrefab(cell_type); DaedalusDebugUtils.Assert(prefab != null, "No variation was chosen for " + cell_type); GameObject go = (GameObject)GameObject.Instantiate(prefab, new Vector3(l.x * behaviour.tileSize, 0, l.y * behaviour.tileSize), Quaternion.identity); go.name = cell_type.ToString(); if (orientation == VirtualMap.DirectionType.None) { orientation = VirtualMap.DirectionType.North; } switch (orientation) { case VirtualMap.DirectionType.West: go.transform.localEulerAngles = new Vector3(90, 0, 0); break; case VirtualMap.DirectionType.North: go.transform.localEulerAngles = new Vector3(90, 90, 0); break; case VirtualMap.DirectionType.East: go.transform.localEulerAngles = new Vector3(90, 180, 0); break; case VirtualMap.DirectionType.South: go.transform.localEulerAngles = new Vector3(90, 270, 0); break; } AddToMapGameObject(cell_type, go, cell_type == VirtualCell.CellType.Door, l.storey); // Move walls up a bit if (VirtualCell.IsFloor(cell_type)) { // Already good } else { go.transform.localPosition += Vector3.up * 0.01f; } }
// Control if we can open a door in the given direction. Open it if possible private void CreateDoor(VirtualMap map, VirtualRoom r, RoomGenerator roomGenerator, CellLocation start_floor_loc, CellLocation end_floor_loc, VirtualMap.DirectionType direction) { CellLocation passage = map.GetNeighbourCellLocation(start_floor_loc, direction); // We check whether we are connecting to another room if (map.IsRoomFloor(end_floor_loc)) { // Room-to-room door roomGenerator.OpenRoomDoor(map, r, start_floor_loc, end_floor_loc, passage, direction); } else { // Room-to-corridor door roomGenerator.OpenCorridorDoor(map, r, start_floor_loc, end_floor_loc, passage, direction); } }
override public void CreateObject(VirtualMap map, MetricLocation l, VirtualCell.CellType cell_type, VirtualMap.DirectionType orientation) { GameObject go = null; if (alreadyCreated && currentIndex < spawnedSpriteGos.Count) { go = spawnedSpriteGos[currentIndex]; currentIndex++; } else { go = (GameObject)GameObject.Instantiate(behaviour.spritePrefab, new Vector3(l.x * behaviour.tileSize, 0, l.y * behaviour.tileSize), Quaternion.identity); spawnedSpriteGos.Add(go); } Sprite sprite = behaviour.GetPrefab(cell_type); go.GetComponent <SpriteRenderer>().sprite = sprite; go.name = cell_type.ToString(); go.GetComponent <BoxCollider2D>().size = new Vector2(behaviour.tileSize, behaviour.tileSize); AddToMapGameObject(cell_type, go); // Debug.Log ("Cell at " + l.x+"-"+l.y + " has orientation " + orientation); go.transform.localEulerAngles = new Vector3(90, 0, 0); switch (orientation) { case VirtualMap.DirectionType.West: go.transform.localEulerAngles = new Vector3(90, 0, 0); break; case VirtualMap.DirectionType.North: go.transform.localEulerAngles = new Vector3(90, 90, 0); break; case VirtualMap.DirectionType.East: go.transform.localEulerAngles = new Vector3(90, 180, 0); break; case VirtualMap.DirectionType.South: go.transform.localEulerAngles = new Vector3(90, 270, 0); break; } // Move walls up a bit if (VirtualCell.IsFloor(cell_type)) { // Already good } else { go.transform.localPosition += Vector3.up * 0.01f; } if (cell_type == VirtualCell.CellType.DoorHorizontalBottom) { go.transform.localPosition += Vector3.forward * behaviour.tileSize * 0.25f; } }
override protected GameObjectChoice[] GetVariations(VirtualCell.CellType cell_type, VirtualMap.DirectionType orientation = VirtualMap.DirectionType.None) { GameObjectChoice[] type_choices = null; //Debug.Log(cell_type); switch (cell_type) { case VirtualCell.CellType.CorridorCeiling: type_choices = corridorCeilingVariations; break; case VirtualCell.CellType.RoomCeiling: type_choices = roomCeilingVariations; break; case VirtualCell.CellType.Ladder: type_choices = ladderVariations; break; case VirtualCell.CellType.Ladder2: type_choices = ladder2Variations; break; default: type_choices = base.GetVariations(cell_type, orientation); break; } return(type_choices); }
public CellInstance(VirtualCell.CellType type, VirtualMap.DirectionType dir) { this.type = type; this.dir = dir; }
override protected GameObjectChoice[] GetVariations(VirtualCell.CellType cell_type, VirtualMap.DirectionType orientation = VirtualMap.DirectionType.None) { // Treats floors as prefab sections GameObjectChoice[] type_choices = null; switch (cell_type) { case VirtualCell.CellType.CorridorFloorU: type_choices = sectionUVariations; break; case VirtualCell.CellType.CorridorFloorI: type_choices = sectionIVariations; break; case VirtualCell.CellType.CorridorFloorL: type_choices = sectionLVariations; break; case VirtualCell.CellType.CorridorFloorT: type_choices = sectionTVariations; break; case VirtualCell.CellType.CorridorFloorX: type_choices = sectionXVariations; break; //case VirtualCell.CellType.Ladder: type_choices = sectionLadderVariations; break; default: type_choices = base.GetVariations(cell_type, orientation); break; } return type_choices; }