public override void Reset()
{
base.Reset();
HallRoomId = 0;
RoomPlayer = null;
}
/// <summary>
/// Room初始化
/// </summary>
/// <param name="players"></param>
public void Init(Player[] players)
{
MaxWaitLoadingTime = 90000;
LoadingBroadcastTime = 1000;
WaitRightTime = 30000;
TimeInit();
for (int i = 0; i < players.Length; i++)
{
if (players[i] == null)
{
continue;
}
players[i].Room = this;
MemberList.Add(players[i].Openid, players[i]);
RoomPlayer roomPlayer = new RoomPlayer
{
Openid = players[i].Openid,
Nickname = players[i].UserData.NickNeam,
HeadImageUrl = players[i].UserData.NickWebPath,
Right = false
};
players[i].TempData.PlayerGameInfo = roomPlayer;
}
GoToConfirmStage();
}
private JoinRoomResponseInfo JoinRoom(long hallRoomId, RoomPlayer roomPlayer)
{
var responseInfo = new JoinRoomResponseInfo();
if (roomPlayer == null)
{
responseInfo.ErrCode = ErrorCode.JoinRoom_Message_Error;
}
else if (_room == null || _room.IsDiposed)
{
responseInfo.ErrCode = ErrorCode.JoinRoom_ServerRoom_Null;
}
else
{
int errCode = 0;
var playerInfo = _room.PlayerJoin(hallRoomId, roomPlayer, out errCode);
if (playerInfo != null)
{
responseInfo.Success = true;
responseInfo.Token = playerInfo.Token;
responseInfo.ErrCode = ErrorCode.None;
_playerInfoManager.AddPlayerInfo(playerInfo.Token, playerInfo);
_logger.InfoFormat("Player({0}), Id:{1}, Name:{2}, ModelId:{3}, TeamId:{4}, Token:{5}", 0,
roomPlayer.Id, roomPlayer.Name, roomPlayer.RoleModelId, roomPlayer.TeamId, playerInfo.Token);
}
else
{
responseInfo.ErrCode = (ErrorCode)errCode;
}
}
responseInfo.PlayerId = roomPlayer != null ? roomPlayer.Id : 0;
return(responseInfo);
}
public bool Remove(RoomPlayer p)
{
bool toReturn = false;
if(players[0] == p) toReturn = true;
players.Remove(p);
return toReturn;
}
protected Room(RoomId roomId, RoomCode roomCode, RoomPlayer host)
{
RoomId = roomId;
RoomCode = roomCode;
Host = host;
Status = RoomStatus.Waiting;
}
/// <summary>
/// 广播加载进度
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void SendLoading(object sender, ElapsedEventArgs e)//广播进度并判断
{
bool Temp = true;
ProtocolBytes bytes = new ProtocolBytes();
bytes.SetProtocol(Fursion_Protocol.Loading);
RoomInitInfo roomplayerInfo = new RoomInitInfo();
foreach (Player player in MemberList.Values)
{
RoomPlayer roomPlayer = player.TempData.PlayerGameInfo;
roomplayerInfo.RoomPlayers.Add(roomPlayer);
}
bytes.AddData(JsonConvert.SerializeObject(roomplayerInfo));
foreach (Player player in MemberList.Values)
{
if (player != null && player.UDPClient != null)
{
UDP.instance.SocketSend(bytes, player.UDPClient);
}
}
foreach (Player player in MemberList.Values)
{
Temp &= player.TempData.PlayerGameInfo.LoadingProgressBool;
}
if (Temp)
{
ToStart();
}
}
// Updates a player's socket connection. The player should be in a room.
// If the player already has an open connection, it is closed and the new one takes place.
public async Task <ICollection <RoomPlayer> > UpdatePlayerConnection(string roomId, string playerId, WebSocket conn)
{
Room oldR;
RoomPlayer player = base.GetPlayerInRoom(roomId, playerId, out oldR);
ICollection <RoomPlayer> beforeUpdate = oldR.Players.PlayerList;
List <RoomPlayer> list = new List <RoomPlayer>();
foreach (RoomPlayer p in beforeUpdate)
{
list.Add(p);
}
Room newR = oldR;
WebSocket oldS = player.socket;
player.socket = conn;
newR.Players.UpdatePlayer(player);
if (base._rooms.TryUpdate(roomId, newR, oldR))
{
Console.WriteLine($"\n[GameRoomManager] updated player connection: {playerId}, for room: {roomId}");
await CloseSocketConn(oldS);
return(list);
}
else
{
Console.WriteLine($"\n[RoomManager] Player '{playerId}' already removed from room '{roomId}'!");
return(null);
}
}
public void HandleRoomJoinPacket(Client client, Packet packet)
{
C2SRoomJoinPacket roomJoinPacket = new C2SRoomJoinPacket(packet);
Room room = this.GameHandler.Rooms.Find(r => r.Id == roomJoinPacket.RoomId);
S2CRoomJoinAnswer roomJoinAnswer = new S2CRoomJoinAnswer(0, 0, 0, 0);
client.PacketStream.Write(roomJoinAnswer);
client.ActiveRoom = room;
S2CRoomInformation roomInformationPacket = new S2CRoomInformation(room);
client.PacketStream.Write(roomInformationPacket);
RoomPlayer roomPlayer = new RoomPlayer();
roomPlayer.Character = client.ActiveCharacter;
roomPlayer.Position = 1;
roomPlayer.Master = false;
room.CurrentPlayers.Add(roomPlayer);
List <Client> clientsInRoom = this.GameHandler.GetClientsInRoom(room.Id);
foreach (Client roomClient in clientsInRoom)
{
S2CRoomPlayerInformation roomPlayerInformationPacket =
new S2CRoomPlayerInformation(room.CurrentPlayers);
roomClient.PacketStream.Write(roomPlayerInformationPacket);
}
}
/// <summary>
/// 获得房间信息
/// </summary>
/// <returns></returns>
public GameMessage GetRoomInfo()
{
GameMessage message = new GameMessage();
message.type = BitConverter.GetBytes((int)Protocol.GetRoomInfo);
List <RoomPlayer> roomPlayers = new List <RoomPlayer>();
//每个玩家的信息
foreach (Player p in playerDic.Values)
{
RoomPlayer roomPlayer = new RoomPlayer();
PlayerInfo playerinfo = new PlayerInfo();
playerinfo.id = p.id;
playerinfo.win = p.data.win;
playerinfo.defeat = p.data.defeat;
roomPlayer.playerinfo = playerinfo;
roomPlayer.team = p.tempData.team;
int isOwner = p.tempData.isOwner ? 1 : 0;
roomPlayer.isOwner = isOwner;
roomPlayers.Add(roomPlayer);
}
message.data = ProtoTransfer.Serialize <List <RoomPlayer> >(roomPlayers);
return(message);
}
// Adds a player to an existing room
public ICollection <string> AddPlayerToRoom(string roomId, RoomPlayer player)
{
Room oldR = GetRoomById(roomId);
if (oldR.Players.ContainsPlayer(player.playerId))
{
throw new AlreadyInLobbyException($"'{player.playerId}' is already in a room.");
}
Room newR = oldR;
if (newR.Players.AddPlayer(player))
{
_rooms.TryUpdate(roomId, newR, oldR);
Console.WriteLine($"\n[RoomManager] player '{player.playerId}' added to room '{roomId}'.");
ICollection <RoomPlayer> playersInRoom = oldR.Players.PlayerList;
List <string> list = new List <string>();
foreach (RoomPlayer p in playersInRoom)
{
list.Add(p.playerId);
}
return(list);
}
else
{
throw new FullRoomException("Maximum 2/4 players allowed in a room, for matchmaking and custom game respectively!");
}
}
public void ChangeLeader(string playerID)
{
// 1. 기존 방장 리셋
// 2. 새로운 방장 임명
for (int i = 0; i < roomPlayers.Count; i++)
{
if (roomPlayers[i].isLeader)
{
roomPlayers[i].isLeader = false;
break;
}
}
for (int i = 0; i < roomPlayers.Count; i++)
{
if (roomPlayers[i].player.PlayerID == playerID)
{
if (roomPlayers[i].player.IsMine())
{
RoomGUI.Instance.ChangeReadyToStartButton();
}
roomPlayers[i].isLeader = true;
this.leader = roomPlayers[i];
SetReady(roomPlayers[i].player.PlayerID, false);
}
}
RoomGUI.Instance.UpdateRoomPlayerUIElement(this);
}
private void AddTankInstance(NetworkConnection conn, bool isGameOngoing)
{
RoomPlayer roomPlayer = conn.identity.gameObject.GetComponent <RoomPlayer>();
m_Clients.Add(conn, roomPlayer);
if (roomPlayer.gameObject != null && roomPlayer != null)
{
Transform startPos = GetStartPosition();
GameObject player = startPos != null
? Instantiate(playerPrefab, startPos.position, startPos.rotation)
: Instantiate(playerPrefab);
TankManager tankManager = roomPlayer.m_Tank;
tankManager.m_Instance = player;
NetworkServer.ReplacePlayerForConnection(conn, tankManager.m_Instance, true);
tankManager.m_SpawnPoint = startPos;
roomPlayer.DisableRoomSettings();
m_Tanks.Add(tankManager);
if (isGameOngoing)
{
m_GameManager.AddPlayer(tankManager, conn);
}
}
}
public override void OnReceive(object session, Stream stream)
{
this.Result = (JoinRoomResult)stream.ReadInt();
this.Room = stream.ReadObject <GameRoom>();
this.SelfPlayer = stream.ReadObject <RoomPlayer>();
this.OtherPlayers = stream.ReadObject <List <object> >();
}
/// Randomizes faction attribution for all players inside a room.
private void AssignDefaultPlayerFactions()
{
Random rng = new Random();
List <int> order = new List <int>();
for (int ix = 0; ix < 4; ix++)
{
order.Add(ix);
}
int nx = 4;
while (nx > 1)
{
nx--;
int k = rng.Next(nx + 1);
int value = order[k];
order[k] = order[nx];
order[nx] = value;
}
List <Faction> factions = (List <Faction>)MapReader.readFactions();
int i = 0;
IEnumerator roomPlayer = this.Players.PlayerList.GetEnumerator();
while (roomPlayer.MoveNext())
{
Console.WriteLine(i);
RoomPlayer rp = (RoomPlayer)roomPlayer.Current;
rp.faction = factions[order[i]].name;
RoomPlayer newCopy = (RoomPlayer)roomPlayer.Current;
Console.WriteLine(newCopy.playerId + "; " + newCopy.faction);
i++;
}
}
public void removeDefeatedPlayers(GameRoom room)
{
IEnumerator roomPlayer = room.Players.PlayerList.GetEnumerator();
while (roomPlayer.MoveNext())
{
RoomPlayer rp = (RoomPlayer)roomPlayer.Current;
Console.WriteLine(1 + ";" + rp.faction);
bool playerDataExists = false;
foreach (PlayerMatchdata data in room.getMatchdata())
{
if (data.playerId.Equals(rp.playerId))
{
playerDataExists = true;
}
}
if (!isFactionActive(rp, room) && !playerDataExists)
{
Console.WriteLine(2 + ";" + rp.faction);
int placement = 4 - room.insertDefeatedPlayer(rp);
//removePlayerFromRoom(rp, room);
rp.placement = placement;
PlayerMatchdata matchdata = new PlayerMatchdata(room.roomId, rp.playerId, rp.placement, rp.armiesCreated, rp.regionsConquered);
room.insertPlayerData(matchdata);
Console.WriteLine("Player to matchdata: " + matchdata.playerId);
}
}
}
public override void OnServerDisconnect(NetworkConnection conn)
{
GameObject disconnectedPlayer = conn.identity.gameObject;
if (IsSceneActive(onlineScene))
{
NetworkServer.Destroy(disconnectedPlayer);
RoomPlayer.UpdatePlayerIndexDueDisc();
}
else
{
NetworkServer.Destroy(m_Clients[conn].gameObject);
m_GameManager.RemovePlayer(disconnectedPlayer);
for (int i = 0; i < m_Tanks.Count; i++)
{
if (m_Tanks[i].m_Instance == disconnectedPlayer)
{
m_Tanks.RemoveAt(i);
}
}
NetworkServer.Destroy(disconnectedPlayer);
}
if (m_Tanks.Count < 1)
{
// Forces the server to shutdown.
Shutdown();
// Reset internal state of the server and start the server again.
Start();
}
}
// Objects are despawned when a runner is shutdown <<-- 왜 안되지
public void OnShutdown(NetworkRunner runner, ShutdownReason shutdownReason)
{
Util.Log($"OnShutDown {shutdownReason}");
SetConnectionStatus(Enum.ConnectionStatus.Disconnected);
(string status, string msg) = ShutdownReasonToHuman(shutdownReason);
//TODO : UI에 뿌려줄거라면! status와 msg 이용하면 됨.
for (int i = RoomPlayer.Players.Count - 1; i >= 0; i--)
{
RoomPlayer player = RoomPlayer.Players[i];
StartCoroutine(player.Co_RemovePlayer());
}
for (int i = PlayerModel.Players.Count - 1; i >= 0; i--)
{
PlayerModel player = PlayerModel.Players[i];
if (!player || !player.Object || player.Object.InputAuthority)
{
continue;
}
StartCoroutine(player.Co_RemovePlayer());
}
if (_runner)
{
Destroy(_runner.gameObject);
}
_pool.ClearPools();
_runner = null;
}
public void addPlayer(int connectionId, GameObject player)
{
RoomPlayer rp = player.GetComponent <RoomPlayer>();
players.Add(rp);
rp.color = ResourceContainer.Instance.playerColors[players.Count - 1].color;
}
public void RESPONSE_CREATE_ROOM(TcpPacket packet)
{
if (packet.header.extra == (int)EXTRA.SUCCESS)
{
SERVERtoCLIENT_CreateRoomPacketData recvData = new SERVERtoCLIENT_CreateRoomPacketData();
recvData.Deserialize(packet);
//LobbyManager.Instance.Release();
LobbySceneGUI.Instance.ChangeLobbyToRoom();
RoomPlayer roomPlayer = RoomManager.Instance.CreateRoomPlayer(GameFramework.Instance.MyPlayer);
roomPlayer.isLeader = true;
Room room = RoomManager.Instance.CreateRoom(recvData.roomName, recvData.roomKey, 1);
room.PushRoomPlayer(new RoomPlayer[] { roomPlayer });
room.Enter();
RoomGUI.Instance.Initialize(room);
RoomGUI.Instance.ChangeReadyToStartButton();
}
else if (packet.header.extra == (int)EXTRA.FAIL)
{
Debug.Log("OVERLAPED ROOM NAME...");
MessageBox messageBox = UIFactory.Instance.Create(UI_ELEMENT.MESSAGE_BOX).GetComponent <MessageBox>();
messageBox.Initialize();
messageBox.AttachUIElement(new Vector2(0, 50), LobbySceneGUI.Instance.lobbyGUI);
messageBox.SetTitle("중복된 방 이름입니다.");
}
}
public void Test()
{
var apc = Apc.Allocate();
apc.FunctionName = RpcMessageType.RequestCreateRoom;
var msg = RequestCreateRoomMessage.Allocate();
msg.HallRoomId = 1;
msg.MapId = 33;
var player = RoomPlayer.Allocate();
player.Id = 4;
msg.Players.Add(player);
{
MemoryStream stream = new MemoryStream();
if (msg != null)
{
_serializer.Serialize(stream, msg);
}
ByteString byteString = ByteString.CopyFrom(stream.ToArray());
apc.Parameters.Add(byteString);
}
NetworkChannelOnMessageReceived(null, 0, apc);
msg.ReleaseReference();
}
void Awake()
{
m_NicknameInput = GetComponentInChildren <InputField>();
m_NicknameInput.onValueChanged.AddListener(delegate { UpdateNickname(); });
m_NicknameInput.onEndEdit.AddListener(delegate { SetNickname(); });
m_RoomPlayer = GetComponentInParent <RoomPlayer>();
}
public void onClick()
{
if (player == null)
{
player = NetworkClient.connection.identity.GetComponent <RoomPlayer>();
}
player.CmdChangeReadyState(!player.readyToBegin);
}
public override async Task <string> OnConnectedHostLobby(RoomPlayer player, bool findMatch)
{
string new_room_id = await base.OnConnectedHostLobby(player, findMatch);
await base.SendMessageAsync(player.socket, JsonConvert.SerializeObject(
new LobbyAlertResponse("new-room-id", new_room_id)));
return(new_room_id);
}
public RoomPlayer CreateRoomPlayer(Player player)
{
RoomPlayer roomPlayer = new RoomPlayer();
roomPlayer.player = player;
roomPlayer.readyState = false;
return(roomPlayer);
}
//static List<Color> unusedColors = new List<Color>();
public void Initialize(RoomPlayer newPlayer)
{
readyButton.onClick.AddListener(newPlayer.ToggleReadyStatus);
//playerNameInput.onEndEdit.AddListener(newPlayer.ChangePlayerName);
colorDropDown.onValueChanged.AddListener(newPlayer.ChangeColor);
SetPlayerName(newPlayer.PhotonPlayer.NickName);
SetReadyStatus(false);
SetColor(0);
}
public void DestroyAllRoomPlayers()
{
foreach (RoomPlayer roomPlayer in m_RoomPlayers)
{
if (roomPlayer != null)
{
NetworkServer.Destroy(roomPlayer.gameObject);
}
RoomPlayer.ResetPlayerIndexDueDisc();
}
}
private void CreatePlayer()
{
roomPlayerList.Clear();
for (int i = 0; i < 2; ++i)
{
Camp camp = (Camp)(1 << i);
RoomPlayer roomPlayer = new RoomPlayer(camp);
roomPlayerList.Add(roomPlayer);
}
}
public void Leave()
{
roomName = "";
roomKey = "";
joinedPlayerCount = 0;
roomPlayers.Clear();
leader = null;
isStartGame = false;
RoomGUI.Instance.Release();
}
public void AddGuest(PlayerId playerId, string userName, CharacterKey characterKey)
{
if (Guest != null)
{
AddDomainEvent(new AddGuestFailedEvent(RoomId, playerId, userName, characterKey));
}
else
{
Guest = new RoomPlayer(playerId, userName, characterKey, 0);
AddDomainEvent(new GuestJoinedRoomEvent(RoomId, playerId, userName, characterKey));
}
}
public void StocMessage_HsPlayerEnter(BinaryReader r)
{
string name = r.ReadUnicode(20);
int pos = r.ReadByte() & 3;//F**k this
RoomPlayer player = new RoomPlayer();
player.name = name;
player.prep = false;
roomPlayers[pos] = player;
realize();
UIHelper.Flash();
}
public override GameObject OnRoomServerCreateGamePlayer(NetworkConnection connection, GameObject roomPlayerObj)
{
RoomPlayer roomPlayer = roomPlayerObj.GetComponent <RoomPlayer>();
GameObject gameObject = Instantiate(playerPrefab);
PlayerController player = gameObject.GetComponent <PlayerController>();
player.ServerSetupPlayer(roomPlayer.GetMatchSettings());
return(gameObject);
}
public void AddPlayer(RoomPlayer roomPlayer)
{
players.Add(roomPlayer);
}