private List <RoomConnection> ConnectRoom(Cell[,] cells, List <Room> processedRooms, Room room)
{
List <RoomConnection> potentialConnections = new List <RoomConnection>();
Vector2Int stageSize = MathHelper.GetArraySize(cells);
foreach (Cell cell in room.Cells)
{
Vector2Int topCellPosition = Direction.Top.ShiftPosition(cell.StagePosition);
if (MathHelper.InRange(topCellPosition, stageSize) && !processedRooms.Contains(cells[topCellPosition.y, topCellPosition.x].Room))
{
potentialConnections.Add(new RoomConnection(cell, Direction.Top, room, cells[topCellPosition.y, topCellPosition.x].Room));
}
Vector2Int rightCellPosition = Direction.Right.ShiftPosition(cell.StagePosition);
if (MathHelper.InRange(rightCellPosition, stageSize) && !processedRooms.Contains(cells[rightCellPosition.y, rightCellPosition.x].Room))
{
potentialConnections.Add(new RoomConnection(cell, Direction.Right, room, cells[rightCellPosition.y, rightCellPosition.x].Room));
}
}
List <RoomConnection> roomConnections = new List <RoomConnection>();
while (potentialConnections.Count != 0)
{
RoomConnection roomConnection = MathHelper.GetRandomElement(potentialConnections);
roomConnections.Add(roomConnection);
potentialConnections.RemoveAll(c => c.To == roomConnection.To);
}
return(roomConnections);
}
// å…³é— WebSocket 连接
public static void CloseConnect()
{
if (RoomConnection != null)
{
RoomConnection.Close();
}
}
public static RoomConnection oppositeOfRoomConnection(RoomConnection roomConnection)
{
switch (roomConnection)
{
case RoomConnection.North:
return(RoomConnection.South);
case RoomConnection.South:
return(RoomConnection.North);
case RoomConnection.East:
return(RoomConnection.West);
case RoomConnection.West:
return(RoomConnection.East);
case RoomConnection.Up:
return(RoomConnection.Down);
case RoomConnection.Down:
return(RoomConnection.Up);
default:
return(RoomConnection.NextLevel);
}
}
public Room BuildRoom(Level level, int width = 15, int length = 9, float density = 0.15f)
{
RoomConnection[] roomConnectionsArray = new RoomConnection[roomConnections.Count];
roomConnections.CopyTo(roomConnectionsArray);
this.room = new Room(level, location, width, length, density, roomConnections.ToList(), isEntrance, maxNumberOfEnemies);
return(this.room);
}
public Vector3Int EntrancePositionOfRoomConnection(RoomConnection roomConnection)
{
Vector3Int roomConnectionPosition = PositionOfRoomConnection(roomConnection);
Vector3Int offset = Vector3Int.zero;
switch (roomConnection)
{
case RoomConnection.North:
offset = Vector3Int.down;
break;
case RoomConnection.South:
offset = Vector3Int.up;
break;
case RoomConnection.East:
offset = Vector3Int.left;
break;
case RoomConnection.West:
offset = Vector3Int.right;
break;
case RoomConnection.Down:
case RoomConnection.Up:
// depends on if it is facing right or left
offset = stairsFacingLeft.Value ? Vector3Int.left : Vector3Int.right;
break;
}
return(roomConnectionPosition + offset);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,AccountId,RoomId")] RoomConnection roomConnection)
{
if (id != roomConnection.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(roomConnection);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RoomConnectionExists(roomConnection.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(roomConnection));
}
public static Vector3Int getNextRoomLocation(Room currentRoom, RoomConnection roomConnection)
{
Vector3Int currentLocation = currentRoom.location;
switch (roomConnection)
{
case RoomConnection.North:
currentLocation.y++;
break;
case RoomConnection.South:
currentLocation.y--;
break;
case RoomConnection.East:
currentLocation.x++;
break;
case RoomConnection.West:
currentLocation.x--;
break;
case RoomConnection.Down:
currentLocation.z--;
break;
case RoomConnection.Up:
currentLocation.z++;
break;
}
return(currentLocation);
}
public void AddRoomConnection(RoomConnection connection)
{
if (!Connections.Contains(connection))
{
Connections.Add(connection);
}
}
public void SetRoomConnection(RoomConnection roomConnection, bool?stairsFacingLeft)
{
this.roomConnection = roomConnection;
switch (roomConnection)
{
case RoomConnection.Up:
case RoomConnection.Down:
case RoomConnection.NextLevel:
spriteRenderer = gameObject.AddComponent <SpriteRenderer>();
spriteRenderer.sortingLayerName = "Items";
break;
}
switch (roomConnection)
{
case RoomConnection.Up:
spriteRenderer.sprite = upstairsSprite;
spriteRenderer.flipX = !stairsFacingLeft.Value;
break;
case RoomConnection.Down:
spriteRenderer.sprite = downstairsSprite;
spriteRenderer.flipX = stairsFacingLeft.Value;
break;
case RoomConnection.NextLevel:
spriteRenderer.sprite = levelExitSprite;
break;
default:
break;
}
}
// Token: 0x06001098 RID: 4248 RVA: 0x00075BF4 File Offset: 0x00073DF4
private bool PlaceRoom(RoomConnection connection, DungeonDB.RoomData roomData, ZoneSystem.SpawnMode mode)
{
Room room = roomData.m_room;
Quaternion quaternion = connection.transform.rotation;
quaternion *= Quaternion.Euler(0f, 180f, 0f);
RoomConnection connection2 = room.GetConnection(connection);
Vector3 pos;
Quaternion rot;
this.CalculateRoomPosRot(connection2, connection.transform.position, quaternion, out pos, out rot);
if (room.m_size.x != 0 && room.m_size.z != 0 && this.TestCollision(room, pos, rot))
{
return(false);
}
this.PlaceRoom(roomData, pos, rot, connection, mode);
if (!room.m_endCap)
{
if (connection.m_allowDoor)
{
DungeonGenerator.m_doorConnections.Add(connection);
}
DungeonGenerator.m_openConnections.Remove(connection);
}
return(true);
}
public Vector3Int PositionOfRoomConnection(RoomConnection roomConnection)
{
int x = 0, y = 0;
switch (roomConnection)
{
case RoomConnection.North:
x = width / 2;
y = length - 1;
break;
case RoomConnection.South:
x = width / 2;
y = 0;
break;
case RoomConnection.East:
x = width - 1;
y = length / 2;
break;
case RoomConnection.West:
x = 0;
y = length / 2;
break;
case RoomConnection.Up:
case RoomConnection.Down:
case RoomConnection.NextLevel:
x = width / 2;
y = length / 2;
break;
}
return(new Vector3Int(x, y, 0));
}
void MakeConnection(DungeonRoom first, DungeonRoom second)
{
var connection = new RoomConnection(new[] { first, second });
first.AddConnection(connection);
second.AddConnection(connection);
}
// Token: 0x06001097 RID: 4247 RVA: 0x00075BA0 File Offset: 0x00073DA0
private void CalculateRoomPosRot(RoomConnection roomCon, Vector3 exitPos, Quaternion exitRot, out Vector3 pos, out Quaternion rot)
{
Quaternion rhs = Quaternion.Inverse(roomCon.transform.localRotation);
rot = exitRot * rhs;
Vector3 localPosition = roomCon.transform.localPosition;
pos = exitPos - rot * localPosition;
}
protected void ProcessConnections()
{
while (AvailableConnections.Count > 0 && BuiltRooms.Count < MaxNumberRooms && BuildAttempts < 200)
{
BuildAttempts++;
// Connection from the available connections.
RoomConnection sourceConnection = AvailableConnections.Dequeue();
Room newRoom = CreateRoom();
// Connection from the room to use
RoomConnection destConnection = PickConnection(newRoom);
// Create a rotation Quaternion that will perform the rotation
// required to make the two normals align.
Quaternion rotate = Quaternion.FromToRotation(
destConnection.transform.forward, sourceConnection.transform.forward * -1);
// Apply the rotation to the room, this will make the normals of
// the attachment points align even if the rooms own world rotation
// is point in some weird direction.
newRoom.transform.rotation = rotate * newRoom.transform.rotation;
rotate = Quaternion.FromToRotation(
sourceConnection.transform.up * -1, destConnection.transform.up);
newRoom.transform.rotation = rotate * newRoom.transform.rotation;
Vector3 translate = sourceConnection.transform.position - destConnection.transform.position;
newRoom.transform.Translate(translate, Space.World);
if (RoomCollides(newRoom))
{
AvailableConnections.Enqueue(sourceConnection);
Destroy(newRoom.gameObject);
continue;
}
sourceConnection.OtherRoomConnection = destConnection;
BuiltRooms.Add(newRoom);
if (newRoom.RoomCollider != null)
{
BuiltColliders.Add(newRoom.RoomCollider);
}
else if (newRoom.collider != null)
{
BuiltColliders.Add(newRoom.collider);
}
// Add all connections from the new room into the queue of available
// rooms except the connection that's about the conencted to.
foreach (RoomConnection connection in newRoom.Connections)
{
if (destConnection == connection)
{
continue;
}
AvailableConnections.Enqueue(connection);
}
}
Complete();
}
public string OpenTheRoom(RoomConnection roomConnection)
{
if (CheckKey(roomConnection))
{
roomConnection.IsOpen = true;
return("The road is open now.");
}
return("It's not possible to open the road.");
}
private void OnGuardReachRoom(GuardStateBrainPBT guard, Room room, RoomConnection roomConnection)
{
if (_allGuards.Contains(guard))
{
guard.SetRoom(null);
if (_nodesToSearch.Count != 0)
{
guard.SearchPoint = GetNextSearchPoint();
}
}
}
public async Task <IActionResult> Create([Bind("Id,AccountId,RoomId")] RoomConnection roomConnection)
{
if (ModelState.IsValid)
{
_context.Add(roomConnection);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(roomConnection));
}
// Token: 0x06001095 RID: 4245 RVA: 0x00075B08 File Offset: 0x00073D08
private void PlaceStartRoom(ZoneSystem.SpawnMode mode)
{
DungeonDB.RoomData roomData = this.FindStartRoom();
RoomConnection entrance = roomData.m_room.GetEntrance();
Quaternion rotation = base.transform.rotation;
Vector3 pos;
Quaternion rot;
this.CalculateRoomPosRot(entrance, base.transform.position, rotation, out pos, out rot);
this.PlaceRoom(roomData, pos, rot, entrance, mode);
}
void Start()
{
roomConnection = new RoomConnection();
UserAccount.defaultUserName();
p_networkManager = NetworkManager.singleton;
if (p_networkManager.matchMaker == null)
{
p_networkManager.StartMatchMaker();
}
}
// Token: 0x060010AD RID: 4269 RVA: 0x00076968 File Offset: 0x00074B68
public bool HaveConnection(RoomConnection other)
{
RoomConnection[] connections = this.GetConnections();
for (int i = 0; i < connections.Length; i++)
{
if (connections[i].m_type == other.m_type)
{
return(true);
}
}
return(false);
}
public void AddRoomConnection(RoomConnection con, Room other)
{
if (roomConnections == null)
{
roomConnections = new List <RoomConnection>();
}
if (!roomConnections.Contains(con))
{
roomConnections.Add(con);
Connections.Add(other);
}
}
// Token: 0x06001092 RID: 4242 RVA: 0x0007599C File Offset: 0x00073B9C
private void FindEndCaps(RoomConnection connection, List <DungeonDB.RoomData> rooms)
{
rooms.Clear();
foreach (DungeonDB.RoomData roomData in DungeonGenerator.m_availableRooms)
{
if (roomData.m_room.m_endCap && roomData.m_room.HaveConnection(connection))
{
rooms.Add(roomData);
}
}
rooms.Shuffle <DungeonDB.RoomData>();
}
public static RoomConnection CreateConnection(Room room1, Room room2)
{
RoomConnection connection = new RoomConnection();
connection.Rooms = new Room[2];
connection.Rooms[0] = room1;
connection.Rooms[1] = room2;
room1.AddRoomConnection(connection, room2);
room2.AddRoomConnection(connection, room1);
return(connection);
}
public static void CreateConnection(Room Room1, Room Room2)
{
if (Room1.Connections.Contains(Room2))
{
return;
}
RoomConnection connection = new RoomConnection();
connection.Rooms = new Room[2];
connection.Rooms[0] = Room1;
connection.Rooms[1] = Room2;
Room1.AddRoomConnection(connection, Room2);
Room2.AddRoomConnection(connection, Room1);
}
public void AddToRoom(string keyCode, string connectionId, string userName, bool isMaster = false)
{
var room = context.Rooms.Single(_ => _.KeyCode == keyCode);
var roomConnection = new RoomConnection()
{
Room = room,
ConnectionId = connectionId,
UserName = userName,
IsMaster = isMaster
};
context.Add(roomConnection);
context.SaveChanges();
}
public void enterRoomConnection(RoomConnection roomConnection)
{
if (roomConnection == RoomConnection.NextLevel)
{
exitLevel();
return;
}
currentRoomController.gameObject.SetActive(false);
currentRoomLocation = Level.getNextRoomLocation(currentRoomController.room, roomConnection);
RoomController nextRoom = currentRoomController;
RoomConnection entranceConnection = Room.oppositeOfRoomConnection(roomConnection);
Vector3Int playerStartingPositionInNextRoom = nextRoom.room.EntrancePositionOfRoomConnection(entranceConnection);
PutPlayerInRoomAtPosition(nextRoom, playerStartingPositionInNextRoom);
}
// Token: 0x060010A0 RID: 4256 RVA: 0x00076454 File Offset: 0x00074654
private DungeonDB.RoomData GetRandomRoom(RoomConnection connection)
{
DungeonGenerator.m_tempRooms.Clear();
foreach (DungeonDB.RoomData roomData in DungeonGenerator.m_availableRooms)
{
if (!roomData.m_room.m_entrance && !roomData.m_room.m_endCap && (!connection || (roomData.m_room.HaveConnection(connection) && connection.m_placeOrder >= roomData.m_room.m_minPlaceOrder)))
{
DungeonGenerator.m_tempRooms.Add(roomData);
}
}
if (DungeonGenerator.m_tempRooms.Count == 0)
{
return(null);
}
return(DungeonGenerator.m_tempRooms[UnityEngine.Random.Range(0, DungeonGenerator.m_tempRooms.Count)]);
}
// Token: 0x06001093 RID: 4243 RVA: 0x00075A18 File Offset: 0x00073C18
private DungeonDB.RoomData FindEndCap(RoomConnection connection)
{
DungeonGenerator.m_tempRooms.Clear();
foreach (DungeonDB.RoomData roomData in DungeonGenerator.m_availableRooms)
{
if (roomData.m_room.m_endCap && roomData.m_room.HaveConnection(connection))
{
DungeonGenerator.m_tempRooms.Add(roomData);
}
}
if (DungeonGenerator.m_tempRooms.Count == 0)
{
return(null);
}
return(DungeonGenerator.m_tempRooms[UnityEngine.Random.Range(0, DungeonGenerator.m_tempRooms.Count)]);
}
public bool CheckKey(RoomConnection roomConnection)
{
if (roomConnection == null || roomConnection.OpeningKey == null)
{
return(false);
}
foreach (var item in player.MyInventory)
{
if (roomConnection.OpeningKey.Equals((Key)item))
{
return(true);
}
}
return(player.MyInventory.Contains(roomConnection.OpeningKey));
}
void CreateConnections(RoomConnection connection)
{
if (_createdConnections.Contains(connection))
{
return;
}
var firstRoom = connection.rooms[0];
var secondRoom = connection.rooms[1];
var isVertical = false;
var isHorizontal = false;
var angle = 0;
if (firstRoom.Column > secondRoom.Column)
{
angle = 180;
}
if (firstRoom.Column != secondRoom.Column)
{
if (firstRoom.Row > secondRoom.Row)
{
angle = angle == 0 ? angle - 25 : angle + 25;
}
else if (firstRoom.Row < secondRoom.Row)
{
angle = angle == 0 ? angle + 25 : angle - 25;
}
if (angle == 0 || angle == 180)
{
isHorizontal = true;
}
}
else
{
angle = firstRoom.Row > secondRoom.Row ? angle - 90 : angle + 90;
isVertical = true;
}
var connect = Instantiate(isVertical ? prefabShortConnection : (isHorizontal ? prefabMiddleConnection : prefabLongConnection), connectionContent);
var firstMapRoom = _mappedRooms[connection.rooms[0].Position];
connect.position = firstMapRoom.transform.position;
connect.Rotate(new Vector3(0, 0, angle));
_createdConnections.Add(connection);
AddConnection(firstMapRoom, connect.gameObject);
}
private void RoomTree_SelectedNodeChanged(object sender, EventArgs e)
{
RoomConnectionsListBox.Items.Clear();
RoomConnectionEndpointListBox.Items.Clear();
RoomListsListBox.Items.Clear();
RoomEventListBox.Items.Clear();
if (RoomTree.SelectedNode == null || RoomTree.SelectedNode.Tag == null)
{
RoomInternalName.Text = "";
RoomDescription.Text = "";
SetEnabledControlsRoomsTab(false);
}
else
{
var room = RoomTree.SelectedNode.Tag as MudData.Room;
RoomInternalName.Text = room.name;
RoomDescription.Text = room.description;
foreach (var conn in room.connections)
{
var connWrap = new RoomConnection();
connWrap.Direction = conn.Key;
connWrap.Endpoint = conn.Value;
RoomConnectionsListBox.Items.Add(connWrap);
}
RoomConnectionsListBox_SelectedIndexChanged(null, null);
if (room.lists != null)
{
foreach (var list in room.lists)
{
RoomListsListBox.Items.Add(list);
}
}
RoomListsListBox_SelectedIndexChanged(null, null);
if (room.events != null)
{
foreach (var item in room.events)
{
RoomEventListBox.Items.Add(item);
}
}
RoomEventListBox_SelectedIndexChanged(null, null);
SetEnabledControlsRoomsTab(true);
}
UnhighlightCommitButton(RoomApplyButton);
}
