// ----------------------------------------------------------------------------
// <copyright file="PunClasses.cs" company="Exit Games GmbH">
// PhotonNetwork Framework for Unity - Copyright (C) 2018 Exit Games GmbH
// </copyright>
// <summary>
// Wraps up smaller classes that don't need their own file.
// </summary>
// <author>developer@exitgames.com</author>
// ----------------------------------------------------------------------------
#pragma warning disable 1587
/// \defgroup publicApi Public API
/// \brief Groups the most important classes that you need to understand early on.
///
/// \defgroup optionalGui Optional Gui Elements
/// \brief Useful GUI elements for PUN.
///
/// \defgroup callbacks Callbacks
/// \brief Callback Interfaces
#pragma warning restore 1587
namespace Photon.Pun
{
using System;
using System.Collections.Generic;
using System.Reflection;
using ExitGames.Client.Photon;
using UnityEngine;
using UnityEngine.SceneManagement;
using Photon.Realtime;
using SupportClassPun = ExitGames.Client.Photon.SupportClass;
/// <summary>Replacement for RPC attribute with different name. Used to flag methods as remote-callable.</summary>
public class PunRPC : Attribute
{
}
/// <summary>
/// This class adds the property photonView, while logging a warning when your game still uses the networkView.
/// </summary>
public class MonoBehaviourPun : MonoBehaviour
{
/// <summary>Cache field for the PhotonView on this GameObject.</summary>
private PhotonView pvCache;
/// <summary>A cached reference to a PhotonView on this GameObject.</summary>
/// <remarks>
/// If you intend to work with a PhotonView in a script, it's usually easier to write this.photonView.
///
/// If you intend to remove the PhotonView component from the GameObject but keep this Photon.MonoBehaviour,
/// avoid this reference or modify this code to use PhotonView.Get(obj) instead.
/// </remarks>
public PhotonView photonView
{
get
{
#if UNITY_EDITOR
// In the editor we want to avoid caching this at design time, so changes in PV structure appear immediately.
if (!Application.isPlaying || this.pvCache == null)
{
this.pvCache = PhotonView.Get(this);
}
#else
if (this.pvCache == null)
{
this.pvCache = PhotonView.Get(this);
}
#endif
return this.pvCache;
}
}
//#if UNITY_EDITOR
//protected virtual void Reset()
//{
// this.pvCache = this.transform.GetParentComponent<PhotonView>();
// if (this.pvCache == null)
// {
// Debug.LogWarning(this.GetType().Name + " requires a PhotonView. No PhotonView was found, so one is being added to GameObject '" + this.transform.root.name + "'");
// this.pvCache = this.transform.root.gameObject.AddComponent<PhotonView>();
// }
//}
//#endif
}
/// <summary>
/// This class provides a .photonView and all callbacks/events that PUN can call. Override the events/methods you want to use.
/// </summary>
/// <remarks>
/// By extending this class, you can implement individual methods as override.
///
/// Do not add <b>new</b> <code>MonoBehaviour.OnEnable</code> or <code>MonoBehaviour.OnDisable</code>
/// Instead, you should override those and call <code>base.OnEnable</code> and <code>base.OnDisable</code>.
///
/// Visual Studio and MonoDevelop should provide the list of methods when you begin typing "override".
/// <b>Your implementation does not have to call "base.method()".</b>
///
/// This class implements all callback interfaces and extends <see cref="Photon.Pun.MonoBehaviourPun"/>.
/// </remarks>
/// \ingroup callbacks
// the documentation for the interface methods becomes inherited when Doxygen builds it.
public class MonoBehaviourPunCallbacks : MonoBehaviourPun, IConnectionCallbacks , IMatchmakingCallbacks , IInRoomCallbacks, ILobbyCallbacks, IWebRpcCallback, IErrorInfoCallback
{
public virtual void OnEnable()
{
PhotonNetwork.AddCallbackTarget(this);
}
public virtual void OnDisable()
{
PhotonNetwork.RemoveCallbackTarget(this);
}
/// <summary>
/// Called to signal that the raw connection got established but before the client can call operation on the server.
/// </summary>
/// <remarks>
/// After the (low level transport) connection is established, the client will automatically send
/// the Authentication operation, which needs to get a response before the client can call other operations.
///
/// Your logic should wait for either: OnRegionListReceived or OnConnectedToMaster.
///
/// This callback is useful to detect if the server can be reached at all (technically).
/// Most often, it's enough to implement OnDisconnected().
///
/// This is not called for transitions from the masterserver to game servers.
/// </remarks>
public virtual void OnConnected()
{
}
/// <summary>
/// Called when the local user/client left a room, so the game's logic can clean up it's internal state.
/// </summary>
/// <remarks>
/// When leaving a room, the LoadBalancingClient will disconnect the Game Server and connect to the Master Server.
/// This wraps up multiple internal actions.
///
/// Wait for the callback OnConnectedToMaster, before you use lobbies and join or create rooms.
/// </remarks>
public virtual void OnLeftRoom()
{
}
/// <summary>
/// Called after switching to a new MasterClient when the current one leaves.
/// </summary>
/// <remarks>
/// This is not called when this client enters a room.
/// The former MasterClient is still in the player list when this method get called.
/// </remarks>
public virtual void OnMasterClientSwitched(Player newMasterClient)
{
}
/// <summary>
/// Called when the server couldn't create a room (OpCreateRoom failed).
/// </summary>
/// <remarks>
/// The most common cause to fail creating a room, is when a title relies on fixed room-names and the room already exists.
/// </remarks>
/// <param name="returnCode">Operation ReturnCode from the server.</param>
/// <param name="message">Debug message for the error.</param>
public virtual void OnCreateRoomFailed(short returnCode, string message)
{
}
/// <summary>
/// Called when a previous OpJoinRoom call failed on the server.
/// </summary>
/// <remarks>
/// The most common causes are that a room is full or does not exist (due to someone else being faster or closing the room).
/// </remarks>
/// <param name="returnCode">Operation ReturnCode from the server.</param>
/// <param name="message">Debug message for the error.</param>
public virtual void OnJoinRoomFailed(short returnCode, string message)
{
}
/// <summary>
/// Called when this client created a room and entered it. OnJoinedRoom() will be called as well.
/// </summary>
/// <remarks>
/// This callback is only called on the client which created a room (see OpCreateRoom).
///
/// As any client might close (or drop connection) anytime, there is a chance that the
/// creator of a room does not execute OnCreatedRoom.
///
/// If you need specific room properties or a "start signal", implement OnMasterClientSwitched()
/// and make each new MasterClient check the room's state.
/// </remarks>
public virtual void OnCreatedRoom()
{
}
/// <summary>
/// Called on entering a lobby on the Master Server. The actual room-list updates will call OnRoomListUpdate.
/// </summary>
/// <remarks>
/// While in the lobby, the roomlist is automatically updated in fixed intervals (which you can't modify in the public cloud).
/// The room list gets available via OnRoomListUpdate.
/// </remarks>
public virtual void OnJoinedLobby()
{
}
/// <summary>
/// Called after leaving a lobby.
/// </summary>
/// <remarks>
/// When you leave a lobby, [OpCreateRoom](@ref OpCreateRoom) and [OpJoinRandomRoom](@ref OpJoinRandomRoom)
/// automatically refer to the default lobby.
/// </remarks>
public virtual void OnLeftLobby()
{
}
/// <summary>
/// Called after disconnecting from the Photon server. It could be a failure or intentional
/// </summary>
/// <remarks>
/// The reason for this disconnect is provided as DisconnectCause.
/// </remarks>
public virtual void OnDisconnected(DisconnectCause cause)
{
}
/// <summary>
/// Called when the Name Server provided a list of regions for your title.
/// </summary>
/// <remarks>Check the RegionHandler class description, to make use of the provided values.</remarks>
/// <param name="regionHandler">The currently used RegionHandler.</param>
public virtual void OnRegionListReceived(RegionHandler regionHandler)
{
}
/// <summary>
/// Called for any update of the room-listing while in a lobby (InLobby) on the Master Server.
/// </summary>
/// <remarks>
/// Each item is a RoomInfo which might include custom properties (provided you defined those as lobby-listed when creating a room).
/// Not all types of lobbies provide a listing of rooms to the client. Some are silent and specialized for server-side matchmaking.
/// </remarks>
public virtual void OnRoomListUpdate(List<RoomInfo> roomList)
{
}
/// <summary>
/// Called when the LoadBalancingClient entered a room, no matter if this client created it or simply joined.
/// </summary>
/// <remarks>
/// When this is called, you can access the existing players in Room.Players, their custom properties and Room.CustomProperties.
///
/// In this callback, you could create player objects. For example in Unity, instantiate a prefab for the player.
///
/// If you want a match to be started "actively", enable the user to signal "ready" (using OpRaiseEvent or a Custom Property).
/// </remarks>
public virtual void OnJoinedRoom()
{
}
/// <summary>
/// Called when a remote player entered the room. This Player is already added to the playerlist.
/// </summary>
/// <remarks>
/// If your game starts with a certain number of players, this callback can be useful to check the
/// Room.playerCount and find out if you can start.
/// </remarks>
public virtual void OnPlayerEnteredRoom(Player newPlayer)
{
}
/// <summary>
/// Called when a remote player left the room or became inactive. Check otherPlayer.IsInactive.
/// </summary>
/// <remarks>
/// If another player leaves the room or if the server detects a lost connection, this callback will
/// be used to notify your game logic.
///
/// Depending on the room's setup, players may become inactive, which means they may return and retake
/// their spot in the room. In such cases, the Player stays in the Room.Players dictionary.
///
/// If the player is not just inactive, it gets removed from the Room.Players dictionary, before
/// the callback is called.
/// </remarks>
public virtual void OnPlayerLeftRoom(Player otherPlayer)
{
}
/// <summary>
/// Called when a previous OpJoinRandom call failed on the server.
/// </summary>
/// <remarks>
/// The most common causes are that a room is full or does not exist (due to someone else being faster or closing the room).
///
/// When using multiple lobbies (via OpJoinLobby or a TypedLobby parameter), another lobby might have more/fitting rooms.<br/>
/// </remarks>
/// <param name="returnCode">Operation ReturnCode from the server.</param>
/// <param name="message">Debug message for the error.</param>
public virtual void OnJoinRandomFailed(short returnCode, string message)
{
}
/// <summary>
/// Called when the client is connected to the Master Server and ready for matchmaking and other tasks.
/// </summary>
/// <remarks>
/// The list of available rooms won't become available unless you join a lobby via LoadBalancingClient.OpJoinLobby.
/// You can join rooms and create them even without being in a lobby. The default lobby is used in that case.
/// </remarks>
public virtual void OnConnectedToMaster()
{
}
/// <summary>
/// Called when a room's custom properties changed. The propertiesThatChanged contains all that was set via Room.SetCustomProperties.
/// </summary>
/// <remarks>
/// Since v1.25 this method has one parameter: Hashtable propertiesThatChanged.<br/>
/// Changing properties must be done by Room.SetCustomProperties, which causes this callback locally, too.
/// </remarks>
/// <param name="propertiesThatChanged"></param>
public virtual void OnRoomPropertiesUpdate(Hashtable propertiesThatChanged)
{
}
/// <summary>
/// Called when custom player-properties are changed. Player and the changed properties are passed as object[].
/// </summary>
/// <remarks>
/// Changing properties must be done by Player.SetCustomProperties, which causes this callback locally, too.
/// </remarks>
///
/// <param name="targetPlayer">Contains Player that changed.</param>
/// <param name="changedProps">Contains the properties that changed.</param>
public virtual void OnPlayerPropertiesUpdate(Player targetPlayer, Hashtable changedProps)
{
}
/// <summary>
/// Called when the server sent the response to a FindFriends request.
/// </summary>
/// <remarks>
/// After calling OpFindFriends, the Master Server will cache the friend list and send updates to the friend
/// list. The friends includes the name, userId, online state and the room (if any) for each requested user/friend.
///
/// Use the friendList to update your UI and store it, if the UI should highlight changes.
/// </remarks>
public virtual void OnFriendListUpdate(List<FriendInfo> friendList)
{
}
/// <summary>
/// Called when your Custom Authentication service responds with additional data.
/// </summary>
/// <remarks>
/// Custom Authentication services can include some custom data in their response.
/// When present, that data is made available in this callback as Dictionary.
/// While the keys of your data have to be strings, the values can be either string or a number (in Json).
/// You need to make extra sure, that the value type is the one you expect. Numbers become (currently) int64.
///
/// Example: void OnCustomAuthenticationResponse(Dictionary<string, object> data) { ... }
/// </remarks>
/// <see cref="https://doc.photonengine.com/en-us/realtime/current/reference/custom-authentication"/>
public virtual void OnCustomAuthenticationResponse(Dictionary<string, object> data)
{
}
/// <summary>
/// Called when the custom authentication failed. Followed by disconnect!
/// </summary>
/// <remarks>
/// Custom Authentication can fail due to user-input, bad tokens/secrets.
/// If authentication is successful, this method is not called. Implement OnJoinedLobby() or OnConnectedToMaster() (as usual).
///
/// During development of a game, it might also fail due to wrong configuration on the server side.
/// In those cases, logging the debugMessage is very important.
///
/// Unless you setup a custom authentication service for your app (in the [Dashboard](https://dashboard.photonengine.com)),
/// this won't be called!
/// </remarks>
/// <param name="debugMessage">Contains a debug message why authentication failed. This has to be fixed during development.</param>
public virtual void OnCustomAuthenticationFailed (string debugMessage)
{
}
//TODO: Check if this needs to be implemented
// in: IOptionalInfoCallbacks
public virtual void OnWebRpcResponse(OperationResponse response)
{
}
//TODO: Check if this needs to be implemented
// in: IOptionalInfoCallbacks
public virtual void OnLobbyStatisticsUpdate(List<TypedLobbyInfo> lobbyStatistics)
{
}
/// <summary>
/// Called when the client receives an event from the server indicating that an error happened there.
/// </summary>
/// <remarks>
/// In most cases this could be either:
/// 1. an error from webhooks plugin (if HasErrorInfo is enabled), read more here:
/// https://doc.photonengine.com/en-us/realtime/current/gameplay/web-extensions/webhooks#options
/// 2. an error sent from a custom server plugin via PluginHost.BroadcastErrorInfoEvent, see example here:
/// https://doc.photonengine.com/en-us/server/current/plugins/manual#handling_http_response
/// 3. an error sent from the server, for example, when the limit of cached events has been exceeded in the room
/// (all clients will be disconnected and the room will be closed in this case)
/// read more here: https://doc.photonengine.com/en-us/realtime/current/gameplay/cached-events#special_considerations
/// </remarks>
/// <param name="errorInfo">object containing information about the error</param>
public virtual void OnErrorInfo(ErrorInfo errorInfo)
{
}
}
/// <summary>
/// Container class for info about a particular message, RPC or update.
/// </summary>
/// \ingroup publicApi
public struct PhotonMessageInfo
{
private readonly int timeInt;
/// <summary>The sender of a message / event. May be null.</summary>
public readonly Player Sender;
public readonly PhotonView photonView;
public PhotonMessageInfo(Player player, int timestamp, PhotonView view)
{
this.Sender = player;
this.timeInt = timestamp;
this.photonView = view;
}
[Obsolete("Use SentServerTime instead.")]
public double timestamp
{
get
{
uint u = (uint) this.timeInt;
double t = u;
return t / 1000.0d;
}
}
public double SentServerTime
{
get
{
uint u = (uint)this.timeInt;
double t = u;
return t / 1000.0d;
}
}
public int SentServerTimestamp
{
get { return this.timeInt; }
}
public override string ToString()
{
return string.Format("[PhotonMessageInfo: Sender='{1}' Senttime={0}]", this.SentServerTime, this.Sender);
}
}
/// <summary>Defines Photon event-codes as used by PUN.</summary>
internal class PunEvent
{
public const byte RPC = 200;
public const byte SendSerialize = 201;
public const byte Instantiation = 202;
public const byte CloseConnection = 203;
public const byte Destroy = 204;
public const byte RemoveCachedRPCs = 205;
public const byte SendSerializeReliable = 206; // TS: added this but it's not really needed anymore
public const byte DestroyPlayer = 207; // TS: added to make others remove all GOs of a player
public const byte OwnershipRequest = 209;
public const byte OwnershipTransfer = 210;
public const byte VacantViewIds = 211;
public const byte OwnershipUpdate = 212;
}
/// <summary>
/// This container is used in OnPhotonSerializeView() to either provide incoming data of a PhotonView or for you to provide it.
/// </summary>
/// <remarks>
/// The IsWriting property will be true if this client is the "owner" of the PhotonView (and thus the GameObject).
/// Add data to the stream and it's sent via the server to the other players in a room.
/// On the receiving side, IsWriting is false and the data should be read.
///
/// Send as few data as possible to keep connection quality up. An empty PhotonStream will not be sent.
///
/// Use either Serialize() for reading and writing or SendNext() and ReceiveNext(). The latter two are just explicit read and
/// write methods but do about the same work as Serialize(). It's a matter of preference which methods you use.
/// </remarks>
/// \ingroup publicApi
public class PhotonStream
{
private List<object> writeData;
private object[] readData;
private int currentItem; //Used to track the next item to receive.
/// <summary>If true, this client should add data to the stream to send it.</summary>
public bool IsWriting { get; private set; }
/// <summary>If true, this client should read data send by another client.</summary>
public bool IsReading
{
get { return !this.IsWriting; }
}
/// <summary>Count of items in the stream.</summary>
public int Count
{
get { return this.IsWriting ? this.writeData.Count : this.readData.Length; }
}
/// <summary>
/// Creates a stream and initializes it. Used by PUN internally.
/// </summary>
public PhotonStream(bool write, object[] incomingData)
{
this.IsWriting = write;
if (!write && incomingData != null)
{
this.readData = incomingData;
}
}
public void SetReadStream(object[] incomingData, int pos = 0)
{
this.readData = incomingData;
this.currentItem = pos;
this.IsWriting = false;
}
internal void SetWriteStream(List<object> newWriteData, int pos = 0)
{
if (pos != newWriteData.Count)
{
throw new Exception("SetWriteStream failed, because count does not match position value. pos: "+ pos + " newWriteData.Count:" + newWriteData.Count);
}
this.writeData = newWriteData;
this.currentItem = pos;
this.IsWriting = true;
}
internal List<object> GetWriteStream()
{
return this.writeData;
}
[Obsolete("Either SET the writeData with an empty List or use Clear().")]
internal void ResetWriteStream()
{
this.writeData.Clear();
}
/// <summary>Read next piece of data from the stream when IsReading is true.</summary>
public object ReceiveNext()
{
if (this.IsWriting)
{
Debug.LogError("Error: you cannot read this stream that you are writing!");
return null;
}
object obj = this.readData[this.currentItem];
this.currentItem++;
return obj;
}
/// <summary>Read next piece of data from the stream without advancing the "current" item.</summary>
public object PeekNext()
{
if (this.IsWriting)
{
Debug.LogError("Error: you cannot read this stream that you are writing!");
return null;
}
object obj = this.readData[this.currentItem];
//this.currentItem++;
return obj;
}
/// <summary>Add another piece of data to send it when IsWriting is true.</summary>
public void SendNext(object obj)
{
if (!this.IsWriting)
{
Debug.LogError("Error: you cannot write/send to this stream that you are reading!");
return;
}
this.writeData.Add(obj);
}
[Obsolete("writeData is a list now. Use and re-use it directly.")]
public bool CopyToListAndClear(List<object> target)
{
if (!this.IsWriting) return false;
target.AddRange(this.writeData);
this.writeData.Clear();
return true;
}
/// <summary>Turns the stream into a new object[].</summary>
public object[] ToArray()
{
return this.IsWriting ? this.writeData.ToArray() : this.readData;
}
/// <summary>
/// Will read or write the value, depending on the stream's IsWriting value.
/// </summary>
public void Serialize(ref bool myBool)
{
if (this.IsWriting)
{
this.writeData.Add(myBool);
}
else
{
if (this.readData.Length > this.currentItem)
{
myBool = (bool) this.readData[this.currentItem];
this.currentItem++;
}
}
}
/// <summary>
/// Will read or write the value, depending on the stream's IsWriting value.
/// </summary>
public void Serialize(ref int myInt)
{
if (this.IsWriting)
{
this.writeData.Add(myInt);
}
else
{
if (this.readData.Length > this.currentItem)
{
myInt = (int) this.readData[this.currentItem];
this.currentItem++;
}
}
}
/// <summary>
/// Will read or write the value, depending on the stream's IsWriting value.
/// </summary>
public void Serialize(ref string value)
{
if (this.IsWriting)
{
this.writeData.Add(value);
}
else
{
if (this.readData.Length > this.currentItem)
{
value = (string) this.readData[this.currentItem];
this.currentItem++;
}
}
}
/// <summary>
/// Will read or write the value, depending on the stream's IsWriting value.
/// </summary>
public void Serialize(ref char value)
{
if (this.IsWriting)
{
this.writeData.Add(value);
}
else
{
if (this.readData.Length > this.currentItem)
{
value = (char) this.readData[this.currentItem];
this.currentItem++;
}
}
}
/// <summary>
/// Will read or write the value, depending on the stream's IsWriting value.
/// </summary>
public void Serialize(ref short value)
{
if (this.IsWriting)
{
this.writeData.Add(value);
}
else
{
if (this.readData.Length > this.currentItem)
{
value = (short) this.readData[this.currentItem];
this.currentItem++;
}
}
}
/// <summary>
/// Will read or write the value, depending on the stream's IsWriting value.
/// </summary>
public void Serialize(ref float obj)
{
if (this.IsWriting)
{
this.writeData.Add(obj);
}
else
{
if (this.readData.Length > this.currentItem)
{
obj = (float) this.readData[this.currentItem];
this.currentItem++;
}
}
}
/// <summary>
/// Will read or write the value, depending on the stream's IsWriting value.
/// </summary>
public void Serialize(ref Player obj)
{
if (this.IsWriting)
{
this.writeData.Add(obj);
}
else
{
if (this.readData.Length > this.currentItem)
{
obj = (Player) this.readData[this.currentItem];
this.currentItem++;
}
}
}
/// <summary>
/// Will read or write the value, depending on the stream's IsWriting value.
/// </summary>
public void Serialize(ref Vector3 obj)
{
if (this.IsWriting)
{
this.writeData.Add(obj);
}
else
{
if (this.readData.Length > this.currentItem)
{
obj = (Vector3) this.readData[this.currentItem];
this.currentItem++;
}
}
}
/// <summary>
/// Will read or write the value, depending on the stream's IsWriting value.
/// </summary>
public void Serialize(ref Vector2 obj)
{
if (this.IsWriting)
{
this.writeData.Add(obj);
}
else
{
if (this.readData.Length > this.currentItem)
{
obj = (Vector2) this.readData[this.currentItem];
this.currentItem++;
}
}
}
/// <summary>
/// Will read or write the value, depending on the stream's IsWriting value.
/// </summary>
public void Serialize(ref Quaternion obj)
{
if (this.IsWriting)
{
this.writeData.Add(obj);
}
else
{
if (this.readData.Length > this.currentItem)
{
obj = (Quaternion) this.readData[this.currentItem];
this.currentItem++;
}
}
}
}
public class SceneManagerHelper
{
public static string ActiveSceneName
{
get
{
Scene s = SceneManager.GetActiveScene();
return s.name;
}
}
public static int ActiveSceneBuildIndex
{
get { return SceneManager.GetActiveScene().buildIndex; }
}
#if UNITY_EDITOR
/// <summary>In Editor, we can access the active scene's name.</summary>
public static string EditorActiveSceneName
{
get { return SceneManager.GetActiveScene().name; }
}
#endif
}
/// <summary>
/// The default implementation of a PrefabPool for PUN, which actually Instantiates and Destroys GameObjects but pools a resource.
/// </summary>
/// <remarks>
/// This pool is not actually storing GameObjects for later reuse. Instead, it's destroying used GameObjects.
/// However, prefabs will be loaded from a Resources folder and cached, which speeds up Instantiation a bit.
///
/// The ResourceCache is public, so it can be filled without relying on the Resources folders.
/// </remarks>
public class DefaultPool : IPunPrefabPool
{
/// <summary>Contains a GameObject per prefabId, to speed up instantiation.</summary>
public readonly Dictionary<string, GameObject> ResourceCache = new Dictionary<string, GameObject>();
/// <summary>Returns an inactive instance of a networked GameObject, to be used by PUN.</summary>
/// <param name="prefabId">String identifier for the networked object.</param>
/// <param name="position">Location of the new object.</param>
/// <param name="rotation">Rotation of the new object.</param>
/// <returns></returns>
public GameObject Instantiate(string prefabId, Vector3 position, Quaternion rotation)
{
GameObject res = null;
bool cached = this.ResourceCache.TryGetValue(prefabId, out res);
if (!cached)
{
res = Resources.Load<GameObject>(prefabId);
if (res == null)
{
Debug.LogError("DefaultPool failed to load \"" + prefabId + "\". Make sure it's in a \"Resources\" folder. Or use a custom IPunPrefabPool.");
}
else
{
this.ResourceCache.Add(prefabId, res);
}
}
bool wasActive = res.activeSelf;
if (wasActive) res.SetActive(false);
GameObject instance =GameObject.Instantiate(res, position, rotation) as GameObject;
if (wasActive) res.SetActive(true);
return instance;
}
/// <summary>Simply destroys a GameObject.</summary>
/// <param name="gameObject">The GameObject to get rid of.</param>
public void Destroy(GameObject gameObject)
{
GameObject.Destroy(gameObject);
}
}
/// <summary>Small number of extension methods that make it easier for PUN to work cross-Unity-versions.</summary>
public static class PunExtensions
{
public static Dictionary<MethodInfo, ParameterInfo[]> ParametersOfMethods = new Dictionary<MethodInfo, ParameterInfo[]>();
public static ParameterInfo[] GetCachedParemeters(this MethodInfo mo)
{
ParameterInfo[] result;
bool cached = ParametersOfMethods.TryGetValue(mo, out result);
if (!cached)
{
result = mo.GetParameters();
ParametersOfMethods[mo] = result;
}
return result;
}
public static PhotonView[] GetPhotonViewsInChildren(this UnityEngine.GameObject go)
{
return go.GetComponentsInChildren<PhotonView>(true) as PhotonView[];
}
public static PhotonView GetPhotonView(this UnityEngine.GameObject go)
{
return go.GetComponent<PhotonView>() as PhotonView;
}
/// <summary>compares the squared magnitude of target - second to given float value</summary>
public static bool AlmostEquals(this Vector3 target, Vector3 second, float sqrMagnitudePrecision)
{
return (target - second).sqrMagnitude < sqrMagnitudePrecision; // TODO: inline vector methods to optimize?
}
/// <summary>compares the squared magnitude of target - second to given float value</summary>
public static bool AlmostEquals(this Vector2 target, Vector2 second, float sqrMagnitudePrecision)
{
return (target - second).sqrMagnitude < sqrMagnitudePrecision; // TODO: inline vector methods to optimize?
}
/// <summary>compares the angle between target and second to given float value</summary>
public static bool AlmostEquals(this Quaternion target, Quaternion second, float maxAngle)
{
return Quaternion.Angle(target, second) < maxAngle;
}
/// <summary>compares two floats and returns true of their difference is less than floatDiff</summary>
public static bool AlmostEquals(this float target, float second, float floatDiff)
{
return Mathf.Abs(target - second) < floatDiff;
}
public static bool CheckIsAssignableFrom(this Type to, Type from)
{
#if !NETFX_CORE
return to.IsAssignableFrom(from);
#else
return to.GetTypeInfo().IsAssignableFrom(from.GetTypeInfo());
#endif
}
public static bool CheckIsInterface(this Type to)
{
#if !NETFX_CORE
return to.IsInterface;
#else
return to.GetTypeInfo().IsInterface;
#endif
}
}
}