You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
628 lines
23 KiB
628 lines
23 KiB
// --------------------------------------------------------------------------------------------------------------------
|
|
// <copyright file="PhotonTeamsManager.cs" company="Exit Games GmbH">
|
|
// Part of: Photon Unity Utilities,
|
|
// </copyright>
|
|
// <summary>
|
|
// Implements teams in a room/game with help of player properties.
|
|
// </summary>
|
|
// <remarks>
|
|
// Teams are defined by name and code. Change this to get more / different teams.
|
|
// There are no rules when / if you can join a team. You could add this in JoinTeam or something.
|
|
// </remarks>
|
|
// <author>developer@exitgames.com</author>
|
|
// --------------------------------------------------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
using Photon.Realtime;
|
|
using Hashtable = ExitGames.Client.Photon.Hashtable;
|
|
|
|
namespace Photon.Pun.UtilityScripts
|
|
{
|
|
[Serializable]
|
|
public class PhotonTeam
|
|
{
|
|
public string Name;
|
|
public byte Code;
|
|
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0} [{1}]", this.Name, this.Code);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Implements teams in a room/game with help of player properties. Access them by Player.GetTeam extension.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Teams are defined by enum Team. Change this to get more / different teams.
|
|
/// There are no rules when / if you can join a team. You could add this in JoinTeam or something.
|
|
/// </remarks>
|
|
[DisallowMultipleComponent]
|
|
public class PhotonTeamsManager : MonoBehaviour, IMatchmakingCallbacks, IInRoomCallbacks
|
|
{
|
|
#if UNITY_EDITOR
|
|
#pragma warning disable 0414
|
|
[SerializeField]
|
|
private bool listFoldIsOpen = true;
|
|
#pragma warning restore 0414
|
|
#endif
|
|
|
|
[SerializeField]
|
|
private List<PhotonTeam> teamsList = new List<PhotonTeam>
|
|
{
|
|
new PhotonTeam { Name = "Blue", Code = 1 },
|
|
new PhotonTeam { Name = "Red", Code = 2 }
|
|
};
|
|
|
|
private Dictionary<byte, PhotonTeam> teamsByCode;
|
|
private Dictionary<string, PhotonTeam> teamsByName;
|
|
|
|
/// <summary>The main list of teams with their player-lists. Automatically kept up to date.</summary>
|
|
private Dictionary<byte, HashSet<Player>> playersPerTeam;
|
|
|
|
/// <summary>Defines the player custom property name to use for team affinity of "this" player.</summary>
|
|
public const string TeamPlayerProp = "_pt";
|
|
|
|
public static event Action<Player, PhotonTeam> PlayerJoinedTeam;
|
|
public static event Action<Player, PhotonTeam> PlayerLeftTeam;
|
|
|
|
private static PhotonTeamsManager instance;
|
|
public static PhotonTeamsManager Instance
|
|
{
|
|
get
|
|
{
|
|
if (instance == null)
|
|
{
|
|
instance = FindObjectOfType<PhotonTeamsManager>();
|
|
if (instance == null)
|
|
{
|
|
GameObject obj = new GameObject();
|
|
obj.name = "PhotonTeamsManager";
|
|
instance = obj.AddComponent<PhotonTeamsManager>();
|
|
}
|
|
instance.Init();
|
|
}
|
|
|
|
return instance;
|
|
}
|
|
}
|
|
|
|
#region MonoBehaviour
|
|
|
|
private void Awake()
|
|
{
|
|
if (instance == null || ReferenceEquals(this, instance))
|
|
{
|
|
this.Init();
|
|
instance = this;
|
|
}
|
|
else
|
|
{
|
|
Destroy(this);
|
|
}
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
PhotonNetwork.AddCallbackTarget(this);
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
PhotonNetwork.RemoveCallbackTarget(this);
|
|
this.ClearTeams();
|
|
}
|
|
|
|
private void Init()
|
|
{
|
|
teamsByCode = new Dictionary<byte, PhotonTeam>(teamsList.Count);
|
|
teamsByName = new Dictionary<string, PhotonTeam>(teamsList.Count);
|
|
playersPerTeam = new Dictionary<byte, HashSet<Player>>(teamsList.Count);
|
|
for (int i = 0; i < teamsList.Count; i++)
|
|
{
|
|
teamsByCode[teamsList[i].Code] = teamsList[i];
|
|
teamsByName[teamsList[i].Name] = teamsList[i];
|
|
playersPerTeam[teamsList[i].Code] = new HashSet<Player>();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IMatchmakingCallbacks
|
|
|
|
void IMatchmakingCallbacks.OnJoinedRoom()
|
|
{
|
|
this.UpdateTeams();
|
|
}
|
|
|
|
void IMatchmakingCallbacks.OnLeftRoom()
|
|
{
|
|
this.ClearTeams();
|
|
}
|
|
|
|
void IInRoomCallbacks.OnPlayerPropertiesUpdate(Player targetPlayer, Hashtable changedProps)
|
|
{
|
|
object temp;
|
|
if (changedProps.TryGetValue(TeamPlayerProp, out temp))
|
|
{
|
|
if (temp == null)
|
|
{
|
|
foreach (byte code in playersPerTeam.Keys)
|
|
{
|
|
if (playersPerTeam[code].Remove(targetPlayer))
|
|
{
|
|
if (PlayerLeftTeam != null)
|
|
{
|
|
PlayerLeftTeam(targetPlayer, teamsByCode[code]);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (temp is byte)
|
|
{
|
|
byte teamCode = (byte) temp;
|
|
// check if player switched teams, remove from previous team
|
|
foreach (byte code in playersPerTeam.Keys)
|
|
{
|
|
if (code == teamCode)
|
|
{
|
|
continue;
|
|
}
|
|
if (playersPerTeam[code].Remove(targetPlayer))
|
|
{
|
|
if (PlayerLeftTeam != null)
|
|
{
|
|
PlayerLeftTeam(targetPlayer, teamsByCode[code]);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
PhotonTeam team = teamsByCode[teamCode];
|
|
if (!playersPerTeam[teamCode].Add(targetPlayer))
|
|
{
|
|
Debug.LogWarningFormat("Unexpected situation while setting team {0} for player {1}, updating teams for all", team, targetPlayer);
|
|
this.UpdateTeams();
|
|
}
|
|
if (PlayerJoinedTeam != null)
|
|
{
|
|
PlayerJoinedTeam(targetPlayer, team);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.LogErrorFormat("Unexpected: custom property key {0} should have of type byte, instead we got {1} of type {2}. Player: {3}",
|
|
TeamPlayerProp, temp, temp.GetType(), targetPlayer);
|
|
}
|
|
}
|
|
}
|
|
|
|
void IInRoomCallbacks.OnPlayerLeftRoom(Player otherPlayer)
|
|
{
|
|
if (otherPlayer.IsInactive)
|
|
{
|
|
return;
|
|
}
|
|
PhotonTeam team = otherPlayer.GetPhotonTeam();
|
|
if (team != null && !playersPerTeam[team.Code].Remove(otherPlayer))
|
|
{
|
|
Debug.LogWarningFormat("Unexpected situation while removing player {0} who left from team {1}, updating teams for all", otherPlayer, team);
|
|
// revert to 'brute force' in case of unexpected situation
|
|
this.UpdateTeams();
|
|
}
|
|
}
|
|
|
|
void IInRoomCallbacks.OnPlayerEnteredRoom(Player newPlayer)
|
|
{
|
|
PhotonTeam team = newPlayer.GetPhotonTeam();
|
|
if (team == null)
|
|
{
|
|
return;
|
|
}
|
|
if (playersPerTeam[team.Code].Contains(newPlayer))
|
|
{
|
|
// player rejoined w/ same team
|
|
return;
|
|
}
|
|
// check if player rejoined w/ different team, remove from previous team
|
|
foreach (var key in teamsByCode.Keys)
|
|
{
|
|
if (playersPerTeam[key].Remove(newPlayer))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (!playersPerTeam[team.Code].Add(newPlayer))
|
|
{
|
|
Debug.LogWarningFormat("Unexpected situation while adding player {0} who joined to team {1}, updating teams for all", newPlayer, team);
|
|
// revert to 'brute force' in case of unexpected situation
|
|
this.UpdateTeams();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private methods
|
|
|
|
private void UpdateTeams()
|
|
{
|
|
this.ClearTeams();
|
|
for (int i = 0; i < PhotonNetwork.PlayerList.Length; i++)
|
|
{
|
|
Player player = PhotonNetwork.PlayerList[i];
|
|
PhotonTeam playerTeam = player.GetPhotonTeam();
|
|
if (playerTeam != null)
|
|
{
|
|
playersPerTeam[playerTeam.Code].Add(player);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ClearTeams()
|
|
{
|
|
foreach (var key in playersPerTeam.Keys)
|
|
{
|
|
playersPerTeam[key].Clear();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public API
|
|
|
|
/// <summary>
|
|
/// Find a PhotonTeam using a team code.
|
|
/// </summary>
|
|
/// <param name="code">The team code.</param>
|
|
/// <param name="team">The team to be assigned if found.</param>
|
|
/// <returns>If successful or not.</returns>
|
|
public bool TryGetTeamByCode(byte code, out PhotonTeam team)
|
|
{
|
|
return teamsByCode.TryGetValue(code, out team);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find a PhotonTeam using a team name.
|
|
/// </summary>
|
|
/// <param name="teamName">The team name.</param>
|
|
/// <param name="team">The team to be assigned if found.</param>
|
|
/// <returns>If successful or not.</returns>
|
|
public bool TryGetTeamByName(string teamName, out PhotonTeam team)
|
|
{
|
|
return teamsByName.TryGetValue(teamName, out team);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets all teams available.
|
|
/// </summary>
|
|
/// <returns>Returns all teams available.</returns>
|
|
public PhotonTeam[] GetAvailableTeams()
|
|
{
|
|
if (teamsList != null)
|
|
{
|
|
return teamsList.ToArray();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets all players joined to a team using a team code.
|
|
/// </summary>
|
|
/// <param name="code">The code of the team.</param>
|
|
/// <param name="members">The array of players to be filled.</param>
|
|
/// <returns>If successful or not.</returns>
|
|
public bool TryGetTeamMembers(byte code, out Player[] members)
|
|
{
|
|
members = null;
|
|
HashSet<Player> players;
|
|
if (this.playersPerTeam.TryGetValue(code, out players))
|
|
{
|
|
members = new Player[players.Count];
|
|
int i = 0;
|
|
foreach (var player in players)
|
|
{
|
|
members[i] = player;
|
|
i++;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets all players joined to a team using a team name.
|
|
/// </summary>
|
|
/// <param name="teamName">The name of the team.</param>
|
|
/// <param name="members">The array of players to be filled.</param>
|
|
/// <returns>If successful or not.</returns>
|
|
public bool TryGetTeamMembers(string teamName, out Player[] members)
|
|
{
|
|
members = null;
|
|
PhotonTeam team;
|
|
if (this.TryGetTeamByName(teamName, out team))
|
|
{
|
|
return this.TryGetTeamMembers(team.Code, out members);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets all players joined to a team.
|
|
/// </summary>
|
|
/// <param name="team">The team which will be used to find players.</param>
|
|
/// <param name="members">The array of players to be filled.</param>
|
|
/// <returns>If successful or not.</returns>
|
|
public bool TryGetTeamMembers(PhotonTeam team, out Player[] members)
|
|
{
|
|
members = null;
|
|
if (team != null)
|
|
{
|
|
return this.TryGetTeamMembers(team.Code, out members);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets all team mates of a player.
|
|
/// </summary>
|
|
/// <param name="player">The player whose team mates will be searched.</param>
|
|
/// <param name="teamMates">The array of players to be filled.</param>
|
|
/// <returns>If successful or not.</returns>
|
|
public bool TryGetTeamMatesOfPlayer(Player player, out Player[] teamMates)
|
|
{
|
|
teamMates = null;
|
|
if (player == null)
|
|
{
|
|
return false;
|
|
}
|
|
PhotonTeam team = player.GetPhotonTeam();
|
|
if (team == null)
|
|
{
|
|
return false;
|
|
}
|
|
HashSet<Player> players;
|
|
if (this.playersPerTeam.TryGetValue(team.Code, out players))
|
|
{
|
|
if (!players.Contains(player))
|
|
{
|
|
Debug.LogWarningFormat("Unexpected situation while getting team mates of player {0} who is joined to team {1}, updating teams for all", player, team);
|
|
// revert to 'brute force' in case of unexpected situation
|
|
this.UpdateTeams();
|
|
}
|
|
teamMates = new Player[players.Count - 1];
|
|
int i = 0;
|
|
foreach (var p in players)
|
|
{
|
|
if (p.Equals(player))
|
|
{
|
|
continue;
|
|
}
|
|
teamMates[i] = p;
|
|
i++;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the number of players in a team by team code.
|
|
/// </summary>
|
|
/// <param name="code">Unique code of the team</param>
|
|
/// <returns>Number of players joined to the team.</returns>
|
|
public int GetTeamMembersCount(byte code)
|
|
{
|
|
PhotonTeam team;
|
|
if (this.TryGetTeamByCode(code, out team))
|
|
{
|
|
return this.GetTeamMembersCount(team);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the number of players in a team by team name.
|
|
/// </summary>
|
|
/// <param name="name">Unique name of the team</param>
|
|
/// <returns>Number of players joined to the team.</returns>
|
|
public int GetTeamMembersCount(string name)
|
|
{
|
|
PhotonTeam team;
|
|
if (this.TryGetTeamByName(name, out team))
|
|
{
|
|
return this.GetTeamMembersCount(team);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the number of players in a team.
|
|
/// </summary>
|
|
/// <param name="team">The team you want to know the size of</param>
|
|
/// <returns>Number of players joined to the team.</returns>
|
|
public int GetTeamMembersCount(PhotonTeam team)
|
|
{
|
|
HashSet<Player> players;
|
|
if (team != null && this.playersPerTeam.TryGetValue(team.Code, out players) && players != null)
|
|
{
|
|
return players.Count;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Unused methods
|
|
|
|
void IMatchmakingCallbacks.OnFriendListUpdate(List<FriendInfo> friendList)
|
|
{
|
|
}
|
|
|
|
void IMatchmakingCallbacks.OnCreatedRoom()
|
|
{
|
|
}
|
|
|
|
void IMatchmakingCallbacks.OnCreateRoomFailed(short returnCode, string message)
|
|
{
|
|
}
|
|
|
|
void IMatchmakingCallbacks.OnJoinRoomFailed(short returnCode, string message)
|
|
{
|
|
}
|
|
|
|
void IMatchmakingCallbacks.OnJoinRandomFailed(short returnCode, string message)
|
|
{
|
|
}
|
|
|
|
void IInRoomCallbacks.OnRoomPropertiesUpdate(Hashtable propertiesThatChanged)
|
|
{
|
|
}
|
|
|
|
void IInRoomCallbacks.OnMasterClientSwitched(Player newMasterClient)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
/// <summary>Extension methods for the Player class that make use of PhotonTeamsManager.</summary>
|
|
public static class PhotonTeamExtensions
|
|
{
|
|
/// <summary>Gets the team the player is currently joined to. Null if none.</summary>
|
|
/// <returns>The team the player is currently joined to. Null if none.</returns>
|
|
public static PhotonTeam GetPhotonTeam(this Player player)
|
|
{
|
|
object teamId;
|
|
PhotonTeam team;
|
|
if (player.CustomProperties.TryGetValue(PhotonTeamsManager.TeamPlayerProp, out teamId) && PhotonTeamsManager.Instance.TryGetTeamByCode((byte)teamId, out team))
|
|
{
|
|
return team;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Join a team.
|
|
/// </summary>
|
|
/// <param name="player">The player who will join a team.</param>
|
|
/// <param name="team">The team to be joined.</param>
|
|
/// <returns></returns>
|
|
public static bool JoinTeam(this Player player, PhotonTeam team)
|
|
{
|
|
if (team == null)
|
|
{
|
|
Debug.LogWarning("JoinTeam failed: PhotonTeam provided is null");
|
|
return false;
|
|
}
|
|
PhotonTeam currentTeam = player.GetPhotonTeam();
|
|
if (currentTeam != null)
|
|
{
|
|
Debug.LogWarningFormat("JoinTeam failed: player ({0}) is already joined to a team ({1}), call SwitchTeam instead", player, team);
|
|
return false;
|
|
}
|
|
return player.SetCustomProperties(new Hashtable { { PhotonTeamsManager.TeamPlayerProp, team.Code } });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Join a team using team code.
|
|
/// </summary>
|
|
/// <param name="player">The player who will join the team.</param>
|
|
/// <param name="teamCode">The code fo the team to be joined.</param>
|
|
/// <returns></returns>
|
|
public static bool JoinTeam(this Player player, byte teamCode)
|
|
{
|
|
PhotonTeam team;
|
|
return PhotonTeamsManager.Instance.TryGetTeamByCode(teamCode, out team) && player.JoinTeam(team);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Join a team using team name.
|
|
/// </summary>
|
|
/// <param name="player">The player who will join the team.</param>
|
|
/// <param name="teamName">The name of the team to be joined.</param>
|
|
/// <returns></returns>
|
|
public static bool JoinTeam(this Player player, string teamName)
|
|
{
|
|
PhotonTeam team;
|
|
return PhotonTeamsManager.Instance.TryGetTeamByName(teamName, out team) && player.JoinTeam(team);
|
|
}
|
|
|
|
/// <summary>Switch that player's team to the one you assign.</summary>
|
|
/// <remarks>Internally checks if this player is in that team already or not. Only team switches are actually sent.</remarks>
|
|
/// <param name="player"></param>
|
|
/// <param name="team"></param>
|
|
public static bool SwitchTeam(this Player player, PhotonTeam team)
|
|
{
|
|
if (team == null)
|
|
{
|
|
Debug.LogWarning("SwitchTeam failed: PhotonTeam provided is null");
|
|
return false;
|
|
}
|
|
PhotonTeam currentTeam = player.GetPhotonTeam();
|
|
if (currentTeam == null)
|
|
{
|
|
Debug.LogWarningFormat("SwitchTeam failed: player ({0}) was not joined to any team, call JoinTeam instead", player);
|
|
return false;
|
|
}
|
|
if (currentTeam.Code == team.Code)
|
|
{
|
|
Debug.LogWarningFormat("SwitchTeam failed: player ({0}) is already joined to the same team {1}", player, team);
|
|
return false;
|
|
}
|
|
return player.SetCustomProperties(new Hashtable { { PhotonTeamsManager.TeamPlayerProp, team.Code } },
|
|
new Hashtable { { PhotonTeamsManager.TeamPlayerProp, currentTeam.Code }});
|
|
}
|
|
|
|
/// <summary>Switch the player's team using a team code.</summary>
|
|
/// <remarks>Internally checks if this player is in that team already or not.</remarks>
|
|
/// <param name="player">The player that will switch teams.</param>
|
|
/// <param name="teamCode">The code of the team to switch to.</param>
|
|
/// <returns>If the team switch request is queued to be sent to the server or done in case offline or not joined to a room yet.</returns>
|
|
public static bool SwitchTeam(this Player player, byte teamCode)
|
|
{
|
|
PhotonTeam team;
|
|
return PhotonTeamsManager.Instance.TryGetTeamByCode(teamCode, out team) && player.SwitchTeam(team);
|
|
}
|
|
|
|
/// <summary>Switch the player's team using a team name.</summary>
|
|
/// <remarks>Internally checks if this player is in that team already or not.</remarks>
|
|
/// <param name="player">The player that will switch teams.</param>
|
|
/// <param name="teamName">The name of the team to switch to.</param>
|
|
/// <returns>If the team switch request is queued to be sent to the server or done in case offline or not joined to a room yet.</returns>
|
|
public static bool SwitchTeam(this Player player, string teamName)
|
|
{
|
|
PhotonTeam team;
|
|
return PhotonTeamsManager.Instance.TryGetTeamByName(teamName, out team) && player.SwitchTeam(team);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Leave the current team if any.
|
|
/// </summary>
|
|
/// <param name="player"></param>
|
|
/// <returns>If the leaving team request is queued to be sent to the server or done in case offline or not joined to a room yet.</returns>
|
|
public static bool LeaveCurrentTeam(this Player player)
|
|
{
|
|
PhotonTeam currentTeam = player.GetPhotonTeam();
|
|
if (currentTeam == null)
|
|
{
|
|
Debug.LogWarningFormat("LeaveCurrentTeam failed: player ({0}) was not joined to any team", player);
|
|
return false;
|
|
}
|
|
return player.SetCustomProperties(new Hashtable {{PhotonTeamsManager.TeamPlayerProp, null}}, new Hashtable {{PhotonTeamsManager.TeamPlayerProp, currentTeam.Code}});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Try to get the team mates.
|
|
/// </summary>
|
|
/// <param name="player">The player to get the team mates of.</param>
|
|
/// <param name="teamMates">The team mates array to fill.</param>
|
|
/// <returns>If successful or not.</returns>
|
|
public static bool TryGetTeamMates(this Player player, out Player[] teamMates)
|
|
{
|
|
return PhotonTeamsManager.Instance.TryGetTeamMatesOfPlayer(player, out teamMates);
|
|
}
|
|
}
|
|
} |