public RandomRoom CreateRoom(WaitUser[] members)
{
string roomID;
do
{
// create a random string of 8 characters
string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
char[] stringChars = new char[8];
Random random = new Random();
for (int i = 0; i < stringChars.Length; i++)
{
stringChars[i] = chars[random.Next(chars.Length)];
}
roomID = new String(stringChars);
} while (SearchRoom(roomID) != null);
RandomRoom room = new RandomRoom
{
ID = roomID,
Members = members
};
RoomList.Add(room);
return(room);
}
public async Task SendMessage(string message)
{
RandomRoom room = RoomManager.Instance.GetRoom(Context.ConnectionId);
if (room != null)
{
await Clients.Group(room.ID).ReceiveMessage(Context.ConnectionId, message);
}
Debug();
}
public async Task SkipChat(int userID, string username)
{
WaitUser user = new WaitUser
{
ConnectionID = Context.ConnectionId,
UserID = userID,
UserName = username
};
RandomRoom usrroom = RoomManager.Instance.GetRoom(user.ConnectionID);
if (usrroom != null)
{
foreach (WaitUser usr in usrroom.Members)
{
if (usr.ConnectionID != user.ConnectionID)
{
user.SkipID.Add(usr.ConnectionID);
}
}
;
}
RandomRoom room = RoomManager.Instance.RemoveRoom(user);
if (room != null)
{
foreach (WaitUser usr in room.Members)
{
await Clients.Group(room.ID).BroadcastMessage($"Người dùng {usr.ConnectionID} đã rời khỏi phòng chat {room.ID}.");
await Groups.RemoveFromGroupAsync(usr.ConnectionID, room.ID);
// Join possible room after leave old room
RandomRoom newroom = RoomManager.Instance.GetRoom(usr.ConnectionID);
if (newroom != null)
{
foreach (WaitUser usr1 in newroom.Members)
{
await Groups.AddToGroupAsync(usr1.ConnectionID, newroom.ID);
await Clients.Group(newroom.ID).BroadcastMessage($"Người dùng {usr1.ConnectionID} đã tham gia phòng chat {newroom.ID}.");
}
}
}
}
// DEBUG
Debug();
}
public async Task LeaveChat(int userID, string username)
{
if (RoomManager.Instance.GetRoom(Context.ConnectionId) != null)
{
// If user leaves while in a room
RandomRoom room = RoomManager.Instance.RemoveRoom(new WaitUser
{
ConnectionID = Context.ConnectionId,
UserID = userID,
UserName = username
});
if (room != null)
{
foreach (WaitUser usr in room.Members)
{
await Clients.Group(room.ID).BroadcastMessage($"Người dùng {usr.ConnectionID} đã rời khỏi phòng chat {room.ID}.");
await Groups.RemoveFromGroupAsync(usr.ConnectionID, room.ID);
// Join possible room after leave old room
RandomRoom newroom = RoomManager.Instance.GetRoom(usr.ConnectionID);
if (newroom != null)
{
foreach (WaitUser usr1 in newroom.Members)
{
await Groups.AddToGroupAsync(usr1.ConnectionID, newroom.ID);
await Clients.Group(newroom.ID).BroadcastMessage($"Người dùng {usr1.ConnectionID} đã tham gia phòng chat {newroom.ID}.");
}
}
}
}
}
else
{
// If user leaves while in queue
QueueManager.Instance.Dequeue(Context.ConnectionId);
}
// DEBUG
Debug();
}
public static GameObject Create(int floorNum, int numEnemies)
{
if (prefab == null)
{
prefab = Resources.Load("Prefabs/Floor");
}
GameObject go = Instantiate(prefab) as GameObject;
RandomFloor rf = go.GetComponent <RandomFloor>();
rf.floorNum = floorNum;
rf.rooms = new List <GameObject>();
for (int i = 0; i < rf.roomCount; i++)
{
GameObject room = RandomRoom.Create(go, i, floorNum, rf.roomCount, hasEnemy: true);
rf.rooms.Add(room);
}
go.transform.localPosition = new Vector3(0.0f, rf.GetFloorY, 0.0f);
return(go);
}
public async Task AddToQueue(int userID, string username, string filter)
{
RandomRoom room = QueueManager.Instance.Enqueue(new WaitUser
{
ConnectionID = Context.ConnectionId,
UserID = userID,
UserName = username,
Filter = filter
});
if (room != null)
{
foreach (WaitUser usr in room.Members)
{
await Groups.AddToGroupAsync(usr.ConnectionID, room.ID);
await Clients.Group(room.ID).BroadcastMessage($"Người dùng {usr.ConnectionID} đã tham gia phòng chat {room.ID}.");
}
}
// DEBUG
Debug();
}
public async Task AddFriend(string token)
{
RandomRoom room = RoomManager.Instance.GetRoom(Context.ConnectionId);
if (room != null)
{
foreach (WaitUser usr in room.Members)
{
if (usr.UserID <= 0)
{
await Clients.Group(room.ID).BroadcastMessage($"Người dùng {Context.ConnectionId} đề xuất kết bạn thất bại vì ít nhất 1 trong 2 người chưa đăng nhập!");
return;
}
if (usr.ConnectionID == Context.ConnectionId)
{
usr.FriendRequest = true;
}
}
await Clients.Group(room.ID).BroadcastMessage($"Người dùng {Context.ConnectionId} đã đề xuất kết bạn!");
// Call API create chat room
if (room.Members.Length >= 2 && room.Members[0].FriendRequest && room.Members[1].FriendRequest)
{
IChatRepo chatRepo = new ChatRepo();
await chatRepo.CreateChatRoom(
room.Members[0].UserID,
room.Members[1].UserID,
room.Members[0].UserName,
room.Members[1].UserName,
token);
}
}
Debug();
}
public RandomRoom RemoveRoom(WaitUser user)
{
for (int i = 0; i < RoomList.Count; i++)
{
for (int j = 0; j < RoomList[i].Members.Length; j++)
{
if (RoomList[i].Members[j].ConnectionID == user.ConnectionID)
{
RoomList[i].Members.SetValue(user, j);
RandomRoom room = RoomList[i];
RoomList.RemoveAt(i);
// Enqueue room memebers after removal
foreach (WaitUser usr1 in room.Members)
{
if (user.SkipID.Count > 0)
{
QueueManager.Instance.Enqueue(usr1);
}
else
{
if (usr1.ConnectionID != user.ConnectionID)
{
QueueManager.Instance.Enqueue(usr1);
}
}
}
// return old room before removal
return(room);
}
}
}
return(null);
}
public int sortLG_Rooms(RandomRoom x, RandomRoom y)
{
if( x.garbage < y.garbage)
{
return -1;
}//if
else if(x.garbage > y.garbage)
{
return 1;
}//if
else
{
return 0;
}//if
}
public void placeLG_Rooms_rand(int minW, int maxW, int minH, int maxH, int numLG_Rooms)
{
int maxHorz = (int)Mathf.Floor(width / (maxW+6));
int maxVert = (int)Mathf.Floor(height / (maxH+6));
int maxNumLG_Rooms = maxHorz * maxVert;
numLG_Rooms = Mathf.Min(numLG_Rooms, maxNumLG_Rooms);
System.Collections.Generic.List<RandomRoom> tempLG_RoomList = new System.Collections.Generic.List<RandomRoom>();
RandomRoom theLG_Room;
for(int i = 0; i < numLG_Rooms; i++)
{
int xx = r.getIntInRange(0, width-maxW);
int yy = r.getIntInRange(0,height-maxH);
theLG_Room = new RandomRoom(xx,yy, minW, maxW, minH, maxH, r);
theLG_Room.garbage = r.getIntInRange(int.MinValue, int.MaxValue);
tempLG_RoomList.Add(theLG_Room);
//int widthDiff = maxW - theLG_Room.width;
//int heightDiff = maxH - theLG_Room.height
}
for(int j = 0; j < numLG_Rooms; j++)
{
theLG_Room = tempLG_RoomList[j];
Rect roomRect = new Rect(theLG_Room.x * tileWidth, theLG_Room.y * tileHeight, theLG_Room.width * tileWidth, theLG_Room.height * tileHeight);
Vector2 center = new Vector2(roomRect.x + Mathf.Floor(roomRect.width/2), roomRect.y + Mathf.Floor(roomRect.height/2));
roomCenterPoints.Add(center);
this.addLG_Room(theLG_Room);
rooms_sorted[center] = theLG_Room;
}//for
tempLG_RoomList.Sort(sortLG_Rooms);
//Using the data in the acutal level, figure out all the room connections
roomTree = new MinimumSpan(roomCenterPoints);
roomConnections = roomTree.createMinimumSpan();
}
//NEED TO REPLACE THIS WITH A SYSTEM THAT DOESN'T MAKE AS MANY OVERLAPPING ROOMS
public void placeLG_Rooms(int minW, int maxW, int minH, int maxH, int numLG_Rooms)
{
int maxLG_RoomsHorz = (int)Mathf.Floor(width/(maxW+3));
int maxLG_RoomsVert = (int)Mathf.Floor(height/(maxH+3));;
int maxNumLG_Rooms = maxLG_RoomsHorz * maxLG_RoomsVert;
numLG_Rooms = Mathf.Min(numLG_Rooms, maxNumLG_Rooms);
System.Collections.Generic.List<RandomRoom> tempLG_RoomList = new System.Collections.Generic.List<RandomRoom>();
RandomRoom theRoom;
//Track all the "buckets" that the "screen" can hold.
bool[,] screenBuckets = createEmptyScreenBucketsArray(maxLG_RoomsHorz, maxLG_RoomsVert);
//Loop until you've spawned all the rooms (numLG_Rooms)
for(var i=0; i<numLG_Rooms; i++)
{
//Choose a random bucket
int x = r.getIntInRange(0, maxLG_RoomsHorz-1);
int y = r.getIntInRange(0, maxLG_RoomsVert-1);
int maxTimesLooped = numLG_Rooms+r.getIntInRange(0, 5);
while(screenBuckets[x,y] == true && maxTimesLooped > 0)
{
//If the bucket is false set it to true and add a room within the bucket bounds
if(x < maxLG_RoomsHorz-1)
{
x++;
}//if
else
{
y++;
if(y > maxLG_RoomsVert-1)
{
y=0; //loop back around
}//if
x=0; //loop back around
}//else
maxTimesLooped--;
}//if
screenBuckets[x,y] = true;
theRoom = new RandomRoom(x*(maxW+3)+1,y*(maxH+3)+1, minW, maxW, minH, maxH, r);
theRoom.garbage = r.getIntInRange(int.MinValue, int.MaxValue);
tempLG_RoomList.Add(theRoom);
}
//tempLG_RoomList.Sort(sortLG_Rooms);
for(int j = 0; j < numLG_Rooms; j++)
{
theRoom = tempLG_RoomList[j];
Rect roomRect = new Rect(theRoom.x * tileWidth, theRoom.y * tileHeight, theRoom.width * tileWidth, theRoom.height * tileHeight);
Vector2 center = new Vector2(roomRect.x + Mathf.Floor(roomRect.width/2), roomRect.y + Mathf.Floor(roomRect.height/2));
roomCenterPoints.Add(center);
this.addLG_Room(theRoom);
rooms_sorted[center] = theRoom;
}//for
//Using the room placement data, figure out all the room connections
roomTree = new MinimumSpan(roomCenterPoints);
roomConnections = roomTree.createMinimumSpan();
}
public static GameObject Create(GameObject parentFloor, int roomID, int floorNum, int roomCount, bool hasEnemy = false)
{
if (prefab == null)
{
prefab = Resources.Load("Prefabs/Room");
}
GameObject go = Instantiate(prefab) as GameObject;
RandomRoom rr = go.GetComponent <RandomRoom>();
RoomLUT roomLUT = go.GetComponent <RoomLUT>();
rr.floorNum = floorNum;
rr.roomID = roomID;
go.transform.SetParent(parentFloor.transform);
var numRoomPieces = rr.roomWidth / rr.roomPieceWidth;
float offset = 0.0f;
if (roomCount % 2 == 0)
{
offset = rr.roomWidth / 2;
}
float floorWidth = rr.roomWidth * roomCount;
bool evenFloor = floorNum % 2 == 0;
if (evenFloor)
{
go.transform.localPosition = new Vector3(-floorWidth / 2 + roomID * rr.roomWidth + offset, 0, 0);
}
else
{
go.transform.localPosition = new Vector3(floorWidth / 2 - roomID * rr.roomWidth - offset, 0, 0);
}
offset = 0.0f;
if (numRoomPieces % 2 == 0)
{
offset = rr.roomPieceWidth / 2;
}
int randomIdx;
for (int i = 0; i < numRoomPieces; i++)
{
GameObject roomPiece = null;
if (i == 0)
{
// instantiate left piece
if ((!evenFloor && floorNum > 1 && roomID == 0) ||
(evenFloor && roomID == roomCount - 1))
{
roomPiece = Instantiate(roomLUT.floorLeftEnd);
}
else
{
randomIdx = rnd.Next(roomLUT.leftPieces.Count);
roomPiece = Instantiate(roomLUT.leftPieces[randomIdx]);
}
}
else if (i == numRoomPieces - 1)
{
// Instantiate right piece
if ((!evenFloor && roomID == roomCount - 1) ||
(evenFloor && roomID == 0))
{
roomPiece = Instantiate(roomLUT.floorRightEnd);
}
else
{
randomIdx = rnd.Next(roomLUT.rightPieces.Count);
roomPiece = Instantiate(roomLUT.rightPieces[randomIdx]);
}
}
else
{
// instantiate center
if (RandomRoom.IsCamp(roomID, floorNum))
{
if (i == 1)
{
roomPiece = Instantiate(roomLUT.campPiece1);
}
else if (i == 2)
{
roomPiece = Instantiate(roomLUT.campPiece2);
}
}
else
{
randomIdx = rnd.Next(roomLUT.centerPieces.Count);
roomPiece = Instantiate(roomLUT.centerPieces[randomIdx]);
}
}
roomPiece.transform.SetParent(go.transform);
rr.roomPieces.Add(roomPiece);
roomPiece.transform.localPosition = new Vector3(rr.roomWidth / 2 - i * rr.roomPieceWidth - offset, 0, 0);
randomIdx = rnd.Next(roomLUT.floorPieces.Count);
GameObject floorPiece = Instantiate(roomLUT.floorPieces[randomIdx]);
floorPiece.transform.SetParent(go.transform);
rr.floorPieces.Add(floorPiece);
floorPiece.transform.localPosition = new Vector3(rr.roomWidth / 2 - i * rr.roomPieceWidth - offset, -rr.roomPieceHeight, 0);
}
if (roomID == roomCount - 1)
{
// Add ladder
rr.ladder = Instantiate(roomLUT.ladder);
rr.ladder.transform.SetParent(go.transform);
if (evenFloor)
{
rr.ladder.transform.localPosition = new Vector3(rr.roomWidth / 2 - rr.ladderMargin, -0.1f, -0.5f);
rr.ladder.transform.Rotate(new Vector3(0, 180, 0));
}
else
{
rr.ladder.transform.localPosition = new Vector3(-rr.roomWidth / 2 + rr.ladderMargin, -0.1f, -0.5f);
}
}
if (hasEnemy && !RandomRoom.IsCamp(roomID, floorNum))
{
randomIdx = rnd.Next(roomLUT.enemies.Count);
rr.enemy = Instantiate(roomLUT.enemies[randomIdx]);
rr.enemy.transform.SetParent(go.transform);
rr.enemy.transform.localPosition = new Vector3(0, 0.0f, 0);
if (evenFloor)
{
rr.enemy.transform.Rotate(new Vector3(0, -90, 0));
}
else
{
rr.enemy.transform.Rotate(new Vector3(0, 90, 0));
}
}
return(go);
}
public RandomRoom Enqueue(WaitUser usr)
{
int maxScore = 0;
WaitUser targetUser = new WaitUser();
if (usr.Filter != null)
{
string[] filterData = usr.Filter.Split(",");
for (int i = 0; i < UserQueue.Count; i++)
{
// Match conditions with filter
if (usr.ConnectionID != UserQueue[i].ConnectionID && !usr.SkipID.Contains(UserQueue[i].ConnectionID)
&& !UserQueue[i].SkipID.Contains(usr.ConnectionID))
{
// Filter
if (UserQueue[i].Filter != null)
{
string[] filterDataI = UserQueue[i].Filter.Split(",");
int score = Similarity(filterData, filterDataI);
if (score > maxScore)
{
maxScore = score;
targetUser = UserQueue[i];
}
}
// RandomRoom room = RoomManager.Instance.CreateRoom(new WaitUser[] {
// usr,
// UserQueue[i]
// });
// Dequeue(i);
// return room;
}
}
}
if (maxScore == 0)
{
// In case no filter found
for (int i = 0; i < UserQueue.Count; i++)
{
if (usr.ConnectionID != UserQueue[i].ConnectionID && !usr.SkipID.Contains(UserQueue[i].ConnectionID)
&& !UserQueue[i].SkipID.Contains(usr.ConnectionID))
{
RandomRoom room = RoomManager.Instance.CreateRoom(new WaitUser[] {
usr,
UserQueue[i]
});
Dequeue(i);
return room;
}
}
}
else
{
// In case match filter found
RandomRoom room = RoomManager.Instance.CreateRoom(new WaitUser[] {
usr,
targetUser
});
Dequeue(targetUser.ConnectionID);
return room;
}
UserQueue.Add(usr);
return null;
}
