/// <summary>
///
/// </summary>
/// <param name="player"></param>
private void OnAcceptedPlayer(PeerPlayer player, string gamingRoom)
{
if (player != null && player.ID == CurrentPlayer.ID)
{
_gamingRoom = gamingRoom;
ConnectToGamingRoom(gamingRoom);
}
}
public void generateEnemy(int posx, int posy, string username)
{
PeerPlayer peer = ObjectFactory.createPeer(posx, posy);
peer.username = username;
peer.transform.SetParent(holders[(int)holderID.PEER]);
peerPlayers.Add(peer);
}
private void PlayerLeaved(PeerPlayer player)
{
CallOnDispatcher(() =>
{
var foundPlayer = this.PlayersInMeshList.FirstOrDefault(p => p.ID == player.ID);
this.PlayersInMeshList.Remove(foundPlayer);
foundPlayer = this.GameMembersList.FirstOrDefault(p => p.ID == player.ID);
this.GameMembersList.Remove(foundPlayer);
});
}
public void Join(PeerPlayer player, string acceptorUri, string groupName)
{
Trace.WriteLine(string.Format("[Server]| '{0}' join {1}", player.ToString(), groupName));
player.ConnectionID = Context.ConnectionId;
player.AcceptorUri = acceptorUri;
this._game.PlayerJoin(player, groupName);
this.Groups.Add(player.ConnectionID, groupName);
this.Clients.OthersInGroup(groupName).PlayerListChanged();
}
internal void NewRoom(string gamingRoom, PeerPlayer owner)
{
var hypotheticalPlayers = GetPlayersFromConnexionID(owner.ConnectionID);
var room = new GameRoom {
Owner = owner, RoomName = gamingRoom, PlayersInGroup = hypotheticalPlayers
};
room.OnTimeToStartGame += room_OnTimeToStartGame;
room.Players.Add(owner);
_rooms.TryAdd(gamingRoom, room);
}
private void UserAcceptGameRequest(PeerPlayer player, string uri)
{
if (_canReceiveARequest)
{
_canReceiveARequest = false;
_uriToAccept = uri;
CallOnDispatcher(() =>
{
DoGameRequestReceived(GetPlayer(player), string.Format("do you want to play with '{0}'", player.NickName));
});
}
}
public static PeerPlayer createPeer(int posX, int posY)
{
GameObject peerObject = (Instantiate(
instance.peerPrefab,
new Vector3(posX, posY, 0),
Quaternion.identity
) as GameObject);
PeerPlayer peer = peerObject.GetComponent <PeerPlayer>();
peer.Initialize(posX, posY);
return(peer);
}
internal void GameOverFor(string gamingRoom, PeerPlayer player)
{
GameRoom room;
if (_rooms.TryGetValue(gamingRoom, out room))
{
lock (room)
{
room.GameOverCount++;
}
}
}
internal bool PlayerWouldLikeToPlay(PeerPlayer player, string acceptorUri, out string gamingRoom)
{
gamingRoom = string.Empty;
var room = _rooms.Values.Where(x => x.Owner.AcceptorUri == acceptorUri && !x.Started).FirstOrDefault();
if (room != null)
{
if (room.TryAdd(player))
{
gamingRoom = room.RoomName;
return(true);
}
}
return(false);
}
internal bool TryAdd(PeerPlayer player)
{
if (Started)
{
return(false);
}
lock (((ICollection)this.Players).SyncRoot)
{
if (this.Players.Count < MAXPLAYERS)
{
this.Players.Add(player);
return(true);
}
}
return(false);
}
internal void StopGame(PeerPlayer player, string gamingRoom)
{
GameRoom room;
if (_rooms.TryGetValue(gamingRoom, out room))
{
if (room.Owner.ID == player.ID)
{
lock (room)
{
room.Started = true;
}
}
_rooms.TryRemove(gamingRoom, out room);
}
}
internal bool PlayerWontPlay(PeerPlayer player, string acceptorUri, out string gamingRoom)
{
gamingRoom = null;
var room = _rooms.Values.Where(x => x.Owner.AcceptorUri == acceptorUri).FirstOrDefault();
if (room != null)
{
lock (((ICollection)room.Players).SyncRoot)
{
room.RefusedCount++;
gamingRoom = room.RoomName;
return(true);
}
}
return(false);
}
internal void PlayerJoin(PeerPlayer player, string groupName)
{
List <PeerPlayer> l;
if (!_players.ContainsKey(groupName))
{
_players.TryAdd(groupName, new List <PeerPlayer>());
}
if (_players.TryGetValue(groupName, out l))
{
lock (((ICollection)l).SyncRoot)
{
l.Add(player);
_groupsByCnx.TryAdd(player.ConnectionID, groupName);
}
}
}
private GeniusTetrisPlayer GetPlayer(PeerPlayer player)
{
return(this.PlayersInMeshList.FirstOrDefault(p => p.ID == player.ID));
}
