public Grid GenerateFromDoor(RoomDoor door, Vector2Int pos) { Grid room; Vector2Int?roomPos; int length = 1; Tilemap tmp = _grid.GetComponentsInChildren <Tilemap>().FirstOrDefault(t => t.gameObject.name == "Ground"); do { for (int i = 0; i < PathSize; i++) { pos = Direction.GoAuto(new Vector2Int(pos.x, pos.y), 1, door.Dir); length++; } if (tmp && !TestCol(tmp, pos, new Vector2Int(1, 1))) { return(null); } room = AvailableRooms[Random.Range(0, AvailableRooms.Length)]; roomPos = CanInsertRoom(room.GetComponent <Room>(), new Vector2Int(pos.x, pos.y), door.Dir); } while (roomPos == null); DrawPath(pos, length, room.GetComponent <Room>().From); room.GetComponent <Room>().Pos = roomPos.GetValueOrDefault(); return(room); }
public void ChangeRoomFrom(RoomDoor door) { // 房間被鎖住了,不切換 if (door.BelongRoom.IsLocked) { return; } // 沒有下一個門,不切換 if (door.NextDoor == null) { return; } // 切換中,不切換 if (gameCamera.IsMoving()) { return; } // 先把玩家移到下一個門的位置 player.transform.position = door.NextDoor.transform.position; // 然後切換攝影機到下一個房間的位置 currentRoom = door.NextDoor.BelongRoom; gameCamera.MoveTo(currentRoom.transform.position); //啟動房間 currentRoom.RoomStart(); }
public MapState Apply(ApplicableOperator op) { this.applicableConnections.Remove(op); RoomDoor roomDoor = op.sourceRoomDoor; RoomDoor otherRoom = op.connectionRoomDoor; openDoors.Remove(roomDoor); lastDoor = roomDoor; otherRoom.room.roomId = rooms.Count; MapState newState = new MapState(); foreach (Room room in rooms) { if (room.roomId == roomDoor.room.roomId) { Room clonedRoom = roomDoor.room.clone(); Door clonedDoor = clonedRoom.GetDoor(roomDoor.door.doorId); Room.ConnectDoors(clonedRoom, clonedDoor, otherRoom.room, otherRoom.door); newState.AddRoom(clonedRoom); } else { newState.AddRoom(room.clone()); } } newState.AddRoom(otherRoom.room); return(newState); }
public ActionResult DeleteConfirmed(int id) { RoomDoor roomDoor = db.RoomDoors.Find(id); db.RoomDoors.Remove(roomDoor); db.SaveChanges(); return(RedirectToAction("Index")); }
public void Temp_OnPlayerTouchRoomDoor(RoomDoor rd) { if (Temp_IsTrialEnd(rd.MyRoom)) { PlayerTypes playerType = Temp_GetTrialEndPlayerType(rd.MyRoom); charLineup.AddPlayerType(playerType); } }
bool isRoomApplicable(RoomDoor roomDoor, Room newRoom) { if (actualState.RoomCount() + actualState.OpenDoorCount() + newRoom.doors.Count - 1 > roomLimit) { return(false); } return(true); }
/// <summary> /// Removes the room from the overall dictionary, sets all door parents and destroys the room object /// </summary> /// <param name="room">Room to destroy</param> /// <param name="roomId">Unique ID of the room</param> private void HandleRoomDespawning(BaseRoom room, Guid roomId) { // Remove the room from overall dictionary roomDictionary.Remove(roomId); Dictionary <Vector2, RoomDoor> roomDoors = room.roomDoors; Dictionary <RoomDoor, BaseRoom> neighboringRooms = new Dictionary <RoomDoor, BaseRoom>(); // Enumerate through the room's doors foreach (KeyValuePair <Vector2, RoomDoor> kvp in roomDoors) { RoomDoor door = kvp.Value; Vector2 doorExit = room.GetDoorExit(door); // Skip doors that don't have another room connected if (!roomLocations.ContainsKey(doorExit)) { continue; } BaseRoom exitRoom = roomLocations[doorExit]; neighboringRooms.Add(door, exitRoom); } // Enumerate through all doors foreach (KeyValuePair <RoomDoor, BaseRoom> kvp in neighboringRooms) { BaseRoom neighboringRoom = kvp.Value; if (neighboringRoom == null) { continue; } RoomDoor currentDoor = kvp.Key; Vector2 setLocation = currentDoor.GetLocation(); // Change connected door's parent to their other connected room so they don't get destroyed currentDoor.transform.SetParent(neighboringRoom.transform); } // Loop through all the tile locations for the room to be destroyed for (int i = 0; i < room.roomLocations.Count; ++i) { Vector2 location = room.roomLocations[i]; if (roomLocations.ContainsKey(location)) { // Remove the tile location from the overall used locations roomLocations.Remove(location); } } // Finally destroy the room object Destroy(room.gameObject); }
public ActionResult Edit([Bind(Include = "Id,Door")] RoomDoor roomDoor) { if (ModelState.IsValid) { db.Entry(roomDoor).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } return(View(roomDoor)); }
// Use this for initialization void Start() { if (Application.isEditor) { Boxcollider = GetComponent <BoxCollider2D>(); DoorCollor = new Color(0, 1, 0, 0.5f); Door = GetComponent <RoomDoor>(); } }
public ActionResult Create([Bind(Include = "Id,Door")] RoomDoor roomDoor) { if (ModelState.IsValid) { db.RoomDoors.Add(roomDoor); db.SaveChanges(); return(RedirectToAction("Index")); } return(View(roomDoor)); }
private void CreateDoor(RoomSpawnData room, Transform doorParent, int sign = 1) { GameObject door = Instantiate(prefabDoor, doorParent); door.transform.position = transform.position + GetHalfRoomWidthVector(room) * sign; Vector3 newScale = door.transform.localScale; newScale.x *= -1.0f * UtilMath.Sign(roomNumber % roomOrder.Length == 1) * sign; door.transform.localScale = newScale; latestDoor = door.GetComponent <RoomDoor>(); }
internal Vector2 GetDoorEntrance(RoomDoor door) { foreach (KeyValuePair <Vector2, BaseRoom> kvp in door.connectedRooms) { if (kvp.Value == this) { return(kvp.Key); } } return(Vector2.zero); }
//Loads the room and replace the player at specified door spawn. private void SwitchToRoom(Room room, RoomDoor door) { LoadRoom(room); //reset position _mainPlayer.transform.position = new Vector3(door.RoomSpawn.x, _mainPlayer.transform.position.y, door.RoomSpawn.y); _mainPlayer.transform.position += _currentRoom.transform.position; //reset camera _mainPlayerCamera.CameraTarget = _mainPlayer.transform.position; _mainPlayerCamera.ResetCameraPos(); //hud HudManager.OnRoomEnter(room.RoomName); }
private void CreateWalls() { List <Vector2> doorExits = GetDoorExits(); foreach (Vector2 tile in this.roomLocations) { List <Vector2> neighboringTiles = RoomGenerator.GetNeighboringTiles(tile); for (int i = 0; i < neighboringTiles.Count; ++i) { Vector2 neighboringTile = neighboringTiles[i]; if (this.roomLocations.Contains(neighboringTile)) { continue; } Vector2 direction = neighboringTile - tile; Vector2 setLocation = tile + (direction * 0.5f); if (this.roomDoors.ContainsKey(setLocation)) { continue; } if (RoomGenerator.roomLocations.ContainsKey(neighboringTile)) { BaseRoom neighboringRoom = RoomGenerator.roomLocations[neighboringTile]; if (neighboringRoom.roomDoors.ContainsKey(setLocation)) { RoomDoor neighborDoor = neighboringRoom.roomDoors[setLocation]; this.roomDoors.Add(setLocation, neighborDoor); continue; } } // Create a wall GameObject obj = Instantiate(RoomGenerator.Instance?.roomWallPrefab, this.transform); // Rotate and position the wall obj.transform.rotation = Quaternion.Euler(0, 0, (direction.y != 0 ? 90 : 0)); obj.transform.position = setLocation; // Adjust to player position obj.transform.position += new Vector3(0, 0, -5); this.roomWalls.Add(setLocation, obj); } } }
// GET: RoomDoors/Delete/5 public ActionResult Delete(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } RoomDoor roomDoor = db.RoomDoors.Find(id); if (roomDoor == null) { return(HttpNotFound()); } return(View(roomDoor)); }
bool isDoorApplicable(RoomDoor roomDoor, Room otherRoom, Door otherDoor) { if (!Door.Opposite(roomDoor.door.position, otherDoor.position)) { return(false); } Room cloneOther = otherRoom.clone(); Room.ConnectDoors(roomDoor.room.clone(), roomDoor.door.clone(), cloneOther, otherDoor.clone()); if (actualState.Overlaps(cloneOther)) { return(false); } return(true); }
public void OnPlayerTouchRoomDoor(RoomDoor rd) { // TEMP TEST: If no Room to go to, open ClustSelect scene! if (string.IsNullOrEmpty(rd.RoomToKey)) { OnPlayerExitRoom(rd.MyRoom); SceneHelper.OpenScene(SceneNames.ClustSelMap); } // Otherwise... else { // TEMP HACK: Tell CharSwapController, in case it's a Trial end. charSwapController.Temp_OnPlayerTouchRoomDoor(rd); GoToRoomDoorRoom(rd); } }
private void GoToRoomDoorRoom(RoomDoor rd) { // Register exiting the Room! OnPlayerExitRoom(rd.MyRoom); // Set the door we're gonna start at! dm.doorToID = rd.DoorToID; // Load the room! int _worldIndex = rd.WorldToIndex == -1 ? rd.MyRoom.WorldIndex : rd.WorldToIndex; // Haven't defined worldToIndex? Stay in my world. RoomData rdTo = dm.GetRoomData(_worldIndex, rd.RoomToKey, false); if (rdTo == null) // Safety check. { Debug.LogWarning("RoomDoor can't go to RoomData; doesn't exist. World: " + _worldIndex + ", RoomKey: " + rd.RoomToKey); } else // There IS a room to go to! Go! { StartGameAtRoom(rdTo); } }
public Vector2Int PosFromDoor(RoomDoor door, Vector2Int pos) { switch (door.Dir) { case Direction.to.SOUTH: return(new Vector2Int(pos.x - door.Pos, pos.y)); case Direction.to.NORTH: return(new Vector2Int(pos.x - door.Pos, pos.y - Size.y + 1)); case Direction.to.WEST: return(new Vector2Int(pos.x, pos.y - door.Pos)); case Direction.to.EAST: return(new Vector2Int(pos.x - Size.x + 1, pos.y - door.Pos)); default: return(pos); } }
private bool CheckForDoor() { var position = transform.position; var hit = Physics2D.Raycast(position, character.transform.right, 1f, DoorLayerMask); Debug.DrawRay(position, character.transform.right, Color.red); if (hit) { var door = hit.transform.GetComponent <RoomDoor>(); if (door != null) { actualDoor = door; return(true); } } return(false); }
public Vector2Int DoorPos(RoomDoor door) { switch (door.Dir) { case Direction.to.SOUTH: return(new Vector2Int(Pos.x + door.Pos, Pos.y)); case Direction.to.NORTH: return(new Vector2Int(Pos.x + door.Pos, Pos.y + Size.y - 1)); case Direction.to.WEST: return(new Vector2Int(Pos.x, Pos.y + door.Pos)); case Direction.to.EAST: return(new Vector2Int(Pos.x + Size.x - 1, Pos.y + door.Pos)); default: return(new Vector2Int(Pos.x, Pos.y)); } }
private Vector3[] CalcDoorPoints(RoomDoor d) { Vector3[] points = { new Vector3(), new Vector3(), new Vector3(), new Vector3() }; Vector3 roomPos = transform.position; switch (d.Side) { case ROOM_SIDE.UP: //Low points points[0] = new Vector3(roomPos.x + d.WallPos - d.DoorSize / 2, transform.position.y, roomPos.z + RoomBounds.y); points[3] = new Vector3(roomPos.x + d.WallPos + d.DoorSize / 2, transform.position.y, roomPos.z + RoomBounds.y); break; case ROOM_SIDE.DOWN: //Low points points[0] = new Vector3(roomPos.x + d.WallPos - d.DoorSize / 2, transform.position.y, roomPos.z); points[3] = new Vector3(roomPos.x + d.WallPos + d.DoorSize / 2, transform.position.y, roomPos.z); break; case ROOM_SIDE.LEFT: //Low points points[0] = new Vector3(roomPos.x, transform.position.y, roomPos.z + d.WallPos - d.DoorSize / 2); points[3] = new Vector3(roomPos.x, transform.position.y, roomPos.z + d.WallPos + d.DoorSize / 2); break; case ROOM_SIDE.RIGHT: //Low points points[0] = new Vector3(roomPos.x + RoomBounds.x, transform.position.y, roomPos.z + d.WallPos - d.DoorSize / 2); points[3] = new Vector3(roomPos.x + RoomBounds.x, transform.position.y, roomPos.z + d.WallPos + d.DoorSize / 2); break; default: break; } //High Points points[1] = points[0] + Vector3.up * _editorDoorHeight; points[2] = points[3] + Vector3.up * _editorDoorHeight; return(points); }
/// <summary> /// Creates a single room that should be connected to the given door /// </summary> /// <param name="door"></param> private static void CreateRoom(RoomDoor door, BaseRoom connectedRoom) { if (door == null || connectedRoom == null) { Debug.LogError("Given door or room is null!"); return; } Vector2 doorExit = connectedRoom.GetDoorExit(door); // Get the first tile locations to start the recursive operation List <Vector2> firstTileLocations = GetOpenNeighboringTiles(doorExit); List <Vector2> roomTiles = new List <Vector2> { doorExit }; UnityEngine.Random.InitState((int)DateTime.UtcNow.Ticks); // Loop through the first locations and start creating tiles foreach (Vector2 pos in firstTileLocations) { float cumulativeChance = Instance.additionalTileChance; roomTiles = RandomRoomLayoutRecursive(roomTiles, cumulativeChance, pos); } // When all room tiles have been found, instantiate the object BaseRoom newRoom = Instantiate(Instance?.baseRoomPrefab); newRoom.roomLocations = roomTiles; // Initialize the room after instantiation newRoom.InitRoom(door); door.connectedRooms[doorExit] = newRoom; PlaceRoom(newRoom); }
List <RoomDoor> GetApplicableConnections(RoomDoor openRoomDoor) { List <RoomDoor> applicableConnections = new List <RoomDoor> (); for (int i = 0; i < templates.Length; i++) { Room act = templates [i]; if (isRoomApplicable(openRoomDoor, act)) { Room actRoom = act.clone(); foreach (Door door in actRoom.doors.Values) { if (isDoorApplicable(openRoomDoor, actRoom, door)) { // Debug.Log ("Applicable room: [Room: " + actRoom.width + "x" + actRoom.height + ", Door: " + door.position + "]"); applicableConnections.Add(new RoomDoor(actRoom, door)); } } } } Shuffle(applicableConnections); return(applicableConnections); }
internal void InitRoom(RoomDoor createdFromDoor) { this.roomId = Guid.NewGuid(); // Add the created room to the manager's list RoomGenerator.roomDictionary.Add(this.roomId, this); foreach (Vector2 pos in this.roomLocations) { // Create a primitive cube to display tile location GameObject obj = GameObject.CreatePrimitive(PrimitiveType.Cube); obj.transform.SetParent(this.transform); obj.transform.localPosition = pos; if (RoomGenerator.Instance?.firstRoom == this) { obj.GetComponent <MeshRenderer>().material.color = Color.black; } } CreateDoors(createdFromDoor); CreateWalls(); }
public void ReAddLastDoor() { openDoors.Add(lastDoor); lastDoor = null; }
public void SetDoorExit(RoomDoor door) { doorExit = door; }
public void SetDoorEntry(RoomDoor door) { doorEntry = door; }
public static void Initialize(DungeonContext context) { context.Database.EnsureCreated(); if (context.Rooms.Any()) { return; } var rooms = new Room[] { new Room { RoomName = "Entry", Material = "Earth", Length = 5, Width = 5 }, new Room { RoomName = "StorageA", Material = "Stone", Length = 3, Width = 7 }, new Room { RoomName = "Dungeon1", Material = "Brick", Length = 5, Width = 3 }, new Room { RoomName = "Dungeon2", Material = "Stone", Length = 4, Width = 4 } }; foreach (Room r in rooms) { context.Rooms.Add(r); } context.SaveChanges(); var doors = new Door[] { new Door { DoorID = 1, Type = "Wood", Location = 2 }, new Door { DoorID = 8, Type = "Stone", Location = 4 }, new Door { DoorID = 12, Type = "Stone", Location = 3 }, new Door { DoorID = 11, Type = "Iron", Location = 2 }, new Door { DoorID = 44, Type = "Wood", Location = 1 } }; foreach (Door d in doors) { context.Doors.Add(d); } context.SaveChanges(); var roomdoors = new RoomDoor[] { new RoomDoor { DoorID = 1, RoomId = 1, Side = Side.East }, new RoomDoor { DoorID = 8, RoomId = 2, Side = Side.North }, new RoomDoor { DoorID = 12, RoomId = 3, Side = Side.West }, new RoomDoor { DoorID = 11, RoomId = 4, Side = Side.North }, new RoomDoor { DoorID = 44, RoomId = 1, Side = Side.South } }; foreach (RoomDoor s in roomdoors) { context.RoomDoors.Add(s); } context.SaveChanges(); }
// ---------------------------------------------------------------- // Initialize // ---------------------------------------------------------------- public void Initialize(GameController _gameControllerRef, Transform tf_world, RoomData _roomData) { gameControllerRef = _gameControllerRef; MyRoomData = _roomData; this.gameObject.name = MyRoomData.RoomKey; GameUtils.ParentAndReset(this.gameObject, tf_world); this.transform.localPosition = PosGlobal; // Position me! // Initialize channels! gateChannels = new GateChannel[5]; for (int i = 0; i < gateChannels.Length; i++) { gateChannels[i] = new GateChannel(this, i); } // Instantiate my props! RoomData rd = MyRoomData; ResourcesHandler rh = ResourcesHandler.Instance; int numProgressGates = 0; // for deteriming their indexes. int numVeils = 0; // for determining their indexes. foreach (PropData propData in rd.allPropDatas) { System.Type pt = propData.GetType(); if (false) { } // Enemies else if (pt == typeof(DweebData)) { Dweeb newProp = Instantiate(rh.Dweeb).GetComponent <Dweeb>(); newProp.Initialize(this, propData as DweebData); } // Grounds else if (pt == typeof(CrateData)) { Crate newProp = Instantiate(rh.Crate).GetComponent <Crate>(); newProp.Initialize(this, propData as CrateData); } else if (pt == typeof(DispGroundData)) { DispGround newProp = Instantiate(rh.DispGround).GetComponent <DispGround>(); newProp.Initialize(this, propData as DispGroundData); } else if (pt == typeof(GateData)) { Gate newProp = Instantiate(rh.Gate).GetComponent <Gate>(); newProp.Initialize(this, propData as GateData); gateChannels[newProp.ChannelID].AddGate(newProp); } else if (pt == typeof(ToggleGroundData)) { ToggleGround newProp = Instantiate(rh.ToggleGround).GetComponent <ToggleGround>(); newProp.Initialize(this, propData as ToggleGroundData); } else if (pt == typeof(PlatformData)) { Platform newProp = Instantiate(rh.Platform).GetComponent <Platform>(); newProp.Initialize(this, propData as PlatformData); } else if (pt == typeof(GroundData)) { Ground newProp = Instantiate(rh.Ground).GetComponent <Ground>(); newProp.Initialize(this, propData as GroundData); } // Everything else! else if (pt == typeof(BatteryData)) { Battery newProp = Instantiate(rh.Battery).GetComponent <Battery>(); newProp.Initialize(this, propData as BatteryData); } else if (pt == typeof(BuzzsawData)) { Buzzsaw newProp = Instantiate(rh.Buzzsaw).GetComponent <Buzzsaw>(); newProp.Initialize(this, propData as BuzzsawData); } else if (pt == typeof(CharBarrelData)) { CharBarrel newProp = Instantiate(rh.CharBarrel).GetComponent <CharBarrel>(); newProp.Initialize(this, propData as CharBarrelData, charBarrels.Count); charBarrels.Add(newProp); } else if (pt == typeof(CharUnlockOrbData)) { CharUnlockOrb newProp = Instantiate(rh.CharUnlockOrb).GetComponent <CharUnlockOrb>(); newProp.Initialize(this, propData as CharUnlockOrbData); } else if (pt == typeof(CameraBoundsData)) { CameraBounds newProp = Instantiate(rh.CameraBounds).GetComponent <CameraBounds>(); newProp.Initialize(this, propData as CameraBoundsData); } else if (pt == typeof(GateButtonData)) { GateButton newProp = Instantiate(rh.GateButton).GetComponent <GateButton>(); newProp.Initialize(this, propData as GateButtonData); gateChannels[newProp.ChannelID].AddButton(newProp); } else if (pt == typeof(GemData)) { Gem newProp = Instantiate(rh.Gem).GetComponent <Gem>(); newProp.Initialize(this, propData as GemData, gems.Count); gems.Add(newProp); } else if (pt == typeof(InfoSignData)) { InfoSign newProp = Instantiate(rh.InfoSign).GetComponent <InfoSign>(); newProp.Initialize(this, propData as InfoSignData); } else if (pt == typeof(LaserData)) { Laser newProp = Instantiate(rh.Laser).GetComponent <Laser>(); newProp.Initialize(this, propData as LaserData); } else if (pt == typeof(LiftData)) { Lift newProp = Instantiate(rh.Lift).GetComponent <Lift>(); newProp.Initialize(this, propData as LiftData); } else if (pt == typeof(PlayerStartData)) { PlayerStart newProp = Instantiate(rh.PlayerStart).GetComponent <PlayerStart>(); newProp.Initialize(this, propData as PlayerStartData); } else if (pt == typeof(ProgressGateData)) { ProgressGate newProp = Instantiate(rh.ProgressGate).GetComponent <ProgressGate>(); newProp.Initialize(this, propData as ProgressGateData, numProgressGates++); } else if (pt == typeof(RoomDoorData)) { RoomDoor newProp = Instantiate(rh.RoomDoor).GetComponent <RoomDoor>(); newProp.Initialize(this, propData as RoomDoorData); } else if (pt == typeof(SnackData)) { Snack newProp = Instantiate(rh.Snack).GetComponent <Snack>(); newProp.Initialize(this, propData as SnackData, snacks.Count); snacks.Add(newProp); } else if (pt == typeof(SpikesData)) { Spikes newProp = Instantiate(rh.Spikes).GetComponent <Spikes>(); newProp.Initialize(this, propData as SpikesData); } else if (pt == typeof(TurretData)) { Turret newProp = Instantiate(rh.Turret).GetComponent <Turret>(); newProp.Initialize(this, propData as TurretData); } else if (pt == typeof(VeilData)) { Veil newProp = Instantiate(rh.Veil).GetComponent <Veil>(); newProp.Initialize(this, propData as VeilData, numVeils++); } else { Debug.LogWarning("PropData not recognized: " + propData); } } AddHardcodedRoomElements(); // For development, add bounds so we don't fall out of unconnected rooms! AutoAddInvisibounds(); roomGizmos.Initialize(this); shutters.Initialize(this); }
public void CloseDoors(RoomDoor[] doors_) { for(int i = 0; i < doors_.Length; i++) { doors_[i].ChangeDoorState(false); } }
public void OpenDoors(RoomDoor[] doors_) { for(int i = 0; i < doors_.Length; i++) { doors_[i].ChangeDoorState(true); } }