/// <summary>
/// Find a network view from an ID
/// </summary>
/// <param name="id"></param>
/// <param name="view"></param>
/// <returns></returns>
public static bool Find(ushort id, out NetworkView view)
{
view = views[id];
if (view != null)
return true;
return false;
}
/// <summary>
/// register a network view you've just added as a component. Assignes the network id.
/// </summary>
/// <param name="view"></param>
public static void RegisterNewView(ref NetworkView view)
{
int addedId;
lock (ViewsLock)
{
addedId = Views.Add(view);
}
view.viewID.guid = (ushort) addedId;
}
internal static void RemoveView(NetworkView view)
{
lock (ViewsLock)
{
var findView = Views[view.viewID.guid];
if (findView != null)
{
if (findView == view)
{
Views.Remove(view.viewID.guid);
}
}
}
}
void SendSecondaryView(NetworkView newView, List<NetConnection> conns)
{
if (conns.Count <= 0) return;
var message = PNetServer.peer.CreateMessage();
message.Write(RPCUtils.AddView);
message.Write(viewID.guid);
message.Write(newView.viewID.guid);
if (newView._customSecondaryFunction != null)
message.Write(newView._customSecondaryFunction);
PNetServer.peer.SendMessage(message, conns, NetDeliveryMethod.ReliableOrdered, Channels.STATIC_UTILS);
}
/// <summary>
/// Destroy the specified view over the network
/// </summary>
/// <param name="view"></param>
public void NetworkDestroy(NetworkView view)
{
GameState.DestroyDelays += () => { DoNetworkDestroy(view); };
}
/// <summary>
/// Destroy the specified view over the network
/// </summary>
/// <param name="view"></param>
/// <param name="reasonCode">specify a reason to be destroying this networkview. Received on client</param>
public void NetworkDestroy(NetworkView view, byte reasonCode = 0)
{
GameState.DestroyDelays += () => DoNetworkDestroy(view, reasonCode);
}
internal static void RegisterView(NetworkView view, ushort viewId)
{
views.Add(viewId, view);
}
/// <summary>
/// register a network view you've just added as a component. Assignes the network id.
/// </summary>
/// <param name="view"></param>
public static void RegisterNewView(ref NetworkView view)
{
view.viewID.guid = (ushort)views.Add(view);
}
/// <summary>
/// Find a network view from an ID
/// </summary>
/// <param name="id"></param>
/// <param name="view"></param>
/// <returns></returns>
public static bool Find(ushort id, out NetworkView view)
{
lock (ViewsLock) {view = Views[id];}
return view != null;
}
internal static void RegisterView(NetworkView view, ushort viewId)
{
lock (ViewsLock) { Views.Add(viewId, view); }
}
internal static void ProcessUtils(NetIncomingMessage msg)
{
//
var utilId = msg.ReadByte();
if (utilId == RPCUtils.TimeUpdate)
{
//Players shouldn't be doing this either..
}
else if (utilId == RPCUtils.Instantiate)
{
//Players shouldn't be instantiating things
//read the path...
//var resourcePath = msg.ReadString();
//var viewId = msg.ReadUInt16();
//var ownerId = msg.ReadUInt16();
//var gobj = Resources.Load(resourcePath);
//var instance = (GameObject)GameObject.Instantiate(gobj);
//look for a networkview..
//var view = instance.GetComponent<NetworkView>();
//if (view)
//{
// NetworkView.RegisterView(view, viewId);
// view.viewID = new NetworkViewId() { guid = viewId, IsMine = PlayerId == ownerId };
//}
}
else if (utilId == RPCUtils.FinishedRoomChange)
{
//the player has finished loading into the new room. now actually put their player in the new room.
var player = msg.SenderConnection.Tag as Player;
var newRoom = player.GetRoomSwitchingTo();
if (newRoom != null)
{
newRoom.AddPlayer(player);
}
}
else if (utilId == RPCUtils.Remove)
{
//Players shouldn't be removing view ids
//var viewId = msg.ReadUInt16();
//NetworkView.RemoveView(viewId);
}
else if (utilId == RPCUtils.FinishedInstantiate)
{
Player player = msg.SenderConnection.Tag as Player;
ushort viewId = msg.ReadUInt16();
NetworkView find;
if (NetworkView.Find(viewId, out find))
{
find.gameObject.OnFinishedInstantiate(player);
}
}
}
private static void Consume(NetIncomingMessage msg)
{
try
{
//faster than switch, as this is in most to least common order
if (msg.SequenceChannel == Channels.UNRELIABLE_STREAM)
{
var actorId = msg.ReadUInt16();
NetworkView find;
if (NetworkView.Find(actorId, out find))
{
Player player = GetPlayer(msg.SenderConnection);
find.OnDeserializeStream(msg, player);
}
}
else if (msg.SequenceChannel == Channels.RELIABLE_STREAM)
{
var actorId = msg.ReadUInt16();
NetworkView find;
if (NetworkView.Find(actorId, out find))
{
Player player = GetPlayer(msg.SenderConnection);
find.OnDeserializeStream(msg, player);
}
}
else if (msg.SequenceChannel >= Channels.BEGIN_RPCMODES && msg.SequenceChannel <= Channels.OWNER_RPC)
{
//rpc...
var viewID = msg.ReadUInt16();
var rpcId = msg.ReadByte();
Player player = GetPlayer(msg.SenderConnection);
NetworkView find;
var info = new NetMessageInfo((RPCMode)(msg.SequenceChannel - Channels.BEGIN_RPCMODES), player);
if (NetworkView.Find(viewID, out find))
{
find.CallRPC(rpcId, msg, info);
//Do we need to forward this still?
if (info.mode != RPCMode.Server && info.continueForwarding)
{
//need to forward...
if (info.mode == RPCMode.Others || info.mode == RPCMode.All)
{
}
else
{
find.Buffer(msg);
}
find.Send(msg, info.mode, msg.SenderConnection);
}
}
}
else if (msg.SequenceChannel == Channels.SYNCHED_FIELD)
{
var viewId = msg.ReadUInt16();
var fieldId = msg.ReadByte();
NetworkView find;
if (NetworkView.Find(viewId, out find))
{
find.BufferField(msg, fieldId);
find.SendField(msg, msg.SenderConnection);
}
}
else if (msg.SequenceChannel == Channels.OBJECT_RPC)
{
Player player = GetPlayer(msg.SenderConnection);
if (player.CurrentRoom != null)
{
player.CurrentRoom.IncomingObjectRPC(msg);
}
}
else if (msg.SequenceChannel == Channels.STATIC_RPC)
{
var rpcId = msg.ReadByte();
var player = GetPlayer(msg.SenderConnection);
var currentRoom = player.CurrentRoom;
if (currentRoom != null)
{
NetMessageInfo info = new NetMessageInfo(RPCMode.None, player);
currentRoom.CallRPC(rpcId, msg, info);
if (info.continueForwarding)
{
var newMessage = peer.CreateMessage();
msg.Clone(newMessage);
currentRoom.SendMessage(newMessage);
}
}
}
else if (msg.SequenceChannel == Channels.STATIC_UTILS)
{
ProcessUtils(msg);
}
else
{
Debug.LogWarning("data received over unhandled channel " + msg.SequenceChannel);
}
}
catch (Exception ex)
{
Debug.Log("[Consumption] {0} : {1}", ex.Message, ex.StackTrace);
}
}
internal static void RegisterView(NetworkView view, ushort viewId)
{
lock(ViewsLock) {Views.Add(viewId, view);}
}
/// <summary>
/// find a networkview via a networkviewid serialize to the message
/// </summary>
/// <param name="message">read location is advanced</param>
/// <param name="view"></param>
/// <returns></returns>
public static bool Find(ref NetIncomingMessage message, out NetworkView view)
{
var id = NetworkViewId.Deserialize(message);
return Find(id, out view);
}
/// <summary>
/// Find a network view from an ID
/// </summary>
/// <param name="id"></param>
/// <param name="view"></param>
/// <returns></returns>
public static bool Find(ushort id, out NetworkView view)
{
lock (ViewsLock) { view = Views[id]; }
return(view != null);
}
/// <summary>
/// find a networkview via a networkviewid serialize to the message
/// </summary>
/// <param name="message">read location is advanced</param>
/// <param name="view"></param>
/// <returns></returns>
public static bool Find(ref NetIncomingMessage message, out NetworkView view)
{
var id = NetworkViewId.Deserialize(message);
return(Find(id, out view));
}
private static void Consume(NetIncomingMessage msg)
{
try
{
//faster than switch, as this is in most to least common order
if (msg.SequenceChannel == Channels.UNRELIABLE_STREAM)
{
if (msg.DeliveryMethod == NetDeliveryMethod.ReliableUnordered)
{
HandleStaticRpc(msg);
}
else
{
var actorId = msg.ReadUInt16();
NetworkView find;
if (NetworkView.Find(actorId, out find))
{
Player player = GetPlayer(msg.SenderConnection);
find.OnDeserializeStream(msg, player);
}
else
{
if (GetPlayer(msg.SenderConnection).CurrentRoom != null)
{
Debug.LogWarning(
"[PNetS.Consume] Player {0} attempted to send unreliable stream data for view {1}, but it does not exist",
msg.SenderConnection.Tag, actorId);
(msg.SenderConnection.Tag as Player).InternalErrorCount++;
}
}
}
}
else if (msg.SequenceChannel == Channels.RELIABLE_STREAM)
{
var actorId = msg.ReadUInt16();
NetworkView find;
if (NetworkView.Find(actorId, out find))
{
Player player = GetPlayer(msg.SenderConnection);
find.OnDeserializeStream(msg, player);
}
else
{
if (GetPlayer(msg.SenderConnection).CurrentRoom != null)
{
Debug.LogWarning(
"[PNetS.Consume] Player {0} attempted to send reliable stream data for view {1}, but it does not exist",
msg.SenderConnection.Tag, actorId);
(msg.SenderConnection.Tag as Player).InternalErrorCount++;
}
}
}
else if (msg.SequenceChannel >= Channels.BEGIN_RPCMODES && msg.SequenceChannel <= Channels.OWNER_RPC)
{
//rpc...
var viewId = msg.ReadUInt16();
var rpcId = msg.ReadByte();
Player player = GetPlayer(msg.SenderConnection);
NetworkView find;
var info = new NetMessageInfo((RPCMode)(msg.SequenceChannel - Channels.BEGIN_RPCMODES), player);
if (NetworkView.Find(viewId, out find))
{
find.CallRPC(rpcId, msg, info);
//Do we need to forward this still?
if (info.mode != RPCMode.Server && info.continueForwarding)
{
//need to forward...
if (info.mode == RPCMode.Others || info.mode == RPCMode.All)
{
}
else
{
find.Buffer(msg);
}
find.Send(msg, info.mode, msg.SenderConnection);
}
}
else
{
if (player.CurrentRoom != null)
{
Debug.LogWarning(
"[PNetS.Consume] Player {0} attempted RPC {1} on view {2}, but the view does not exist",
player, rpcId, viewId);
player.InternalErrorCount++;
}
}
}
else if (msg.SequenceChannel == Channels.SYNCHED_FIELD)
{
var viewId = msg.ReadUInt16();
var fieldId = msg.ReadByte();
NetworkView find;
if (NetworkView.Find(viewId, out find))
{
find.BufferField(msg, fieldId);
find.SendField(msg, msg.SenderConnection);
}
}
else if (msg.SequenceChannel == Channels.OBJECT_RPC)
{
Player player = GetPlayer(msg.SenderConnection);
if (player.CurrentRoom != null)
{
player.CurrentRoom.IncomingObjectRPC(msg);
}
}
else if (msg.SequenceChannel == Channels.STATIC_RPC)
{
HandleStaticRpc(msg);
}
else if (msg.SequenceChannel == Channels.STATIC_UTILS)
{
ProcessUtils(msg);
}
else
{
Debug.LogWarning("{2} bytes received over unhandled channel {0}, delivery {1}", msg.SequenceChannel, msg.DeliveryMethod, msg.LengthBytes);
(msg.SenderConnection.Tag as Player).InternalErrorCount++;
}
}
catch (Exception ex)
{
Debug.Log("[Consumption] {0} : {1}", ex.Message, ex.StackTrace);
}
}
//The following methods are all run by the game machine during the life of this componet
/// <summary>
/// Called right after the component is added.
/// If AddComponents(params Type[]) is used to add this, it will get called after all the components have been added
/// </summary>
void Awake()
{
netView = GetComponent<NetworkView>();
netView.SetSerializationMethod(Serialize);
netView.OnDeserializeStream += OnDeserializeStream;
}
/// <summary>
/// Destroy the specified view over the network
/// </summary>
/// <param name="view"></param>
public void NetworkDestroy(NetworkView view)
{
m_Actors.Remove(view);
GameObject.Destroy(view.gameObject);
var msg = PNetServer.peer.CreateMessage(3);
msg.Write(RPCUtils.Remove);
msg.Write(view.viewID.guid);
NetworkView.RemoveView(view.viewID.guid);
//send a destruction message to everyone, just in case.
var connections = players.Select(p => p.connection).ToList();
if (connections.Count == 0) return;
PNetServer.peer.SendMessage(msg, connections, NetDeliveryMethod.ReliableOrdered, Channels.STATIC_UTILS);
}
