protected override void NetworkStart()
{
base.NetworkStart();
OwningNetWorker.AddCustomDataReadEvent(WriteCustomMapping.NETWORKING_MANAGER_PLAYER_LOADED_LEVEL, PlayerLoadedLevel, true);
OwningNetWorker.AddCustomDataReadEvent(WriteCustomMapping.NETWORKED_MONO_BEHAVIOR_MANUAL_PROPERTIES, DeserializeManualProperties, true);
OwningNetWorker.AddCustomDataReadEvent(WriteCustomMapping.TRANSPORT_OBJECT, ReadTransportObject, true);
if (loadLevelFireOnConnect != null)
{
loadLevelFireOnConnect();
loadLevelFireOnConnect = null;
}
}
private void PollPlayersResponse(NetworkingPlayer sender, NetworkingStream stream)
{
int count = ObjectMapper.Map <int>(stream);
List <NetworkingPlayer> playerList = new List <NetworkingPlayer>();
for (int i = 0; i < count; i++)
{
playerList.Add(new NetworkingPlayer(ObjectMapper.Map <ulong>(stream), string.Empty, string.Empty, ObjectMapper.Map <string>(stream)));
}
if (pollPlayersCallback != null)
{
pollPlayersCallback(playerList);
}
OwningNetWorker.AssignPlayers(playerList);
}
/// <summary>
/// To Invoke an RPC on a given Networking Stream RPC
/// </summary>
/// <param name="stream">Networking Stream RPC to read from</param>
public bool InvokeRPC(NetworkingStreamRPC stream)
{
lock (rpcStackMutex)
{
tmpRPCMapId = ObjectMapper.Map <int>(stream);
if (!RPCs.ContainsKey(tmpRPCMapId))
{
return(true);
}
stream.SetName(RPCs[tmpRPCMapId].Key.Name);
List <object> args = new List <object>();
MethodInfo invoke = null;
List <IBRPCIntercept> attributes = null;
foreach (KeyValuePair <int, KeyValuePair <MethodInfo, List <IBRPCIntercept> > > m in RPCs)
{
if (m.Value.Key.Name == stream.MethodName)
{
invoke = m.Value.Key;
attributes = m.Value.Value;
break;
}
}
int start = stream.Bytes.StartIndex(stream.ByteReadIndex);
ParameterInfo[] pars = invoke.GetParameters();
foreach (ParameterInfo p in pars)
{
if (p.ParameterType == typeof(MessageInfo))
{
args.Add(new MessageInfo(stream.RealSenderId, stream.FrameIndex));
}
else
{
args.Add(ObjectMapper.Map(p.ParameterType, stream));
}
}
stream.SetArguments(args.ToArray());
if (ReferenceEquals(this, NetworkingManager.Instance))
{
if (OwningNetWorker.IsServer)
{
if (stream.MethodName == NetworkingStreamRPC.INSTANTIATE_METHOD_NAME)
{
stream.Arguments[1] = stream.SetupInstantiateId(stream, start);
}
else if (stream.MethodName == NetworkingStreamRPC.DESTROY_METHOD_NAME)
{
if (OwningNetWorker.ClearBufferedInstantiateFromID((ulong)args[0]))
{
// Set flag if method removed instantiate
IsClearedForBuffer = !stream.BufferedRPC;
}
}
}
}
foreach (IBRPCIntercept interceptor in attributes)
{
if (!interceptor.ValidateRPC(stream))
{
return(false);
}
}
rpcStack.Add(stream);
return(true);
}
}
/// <summary>
/// This method is used to do all of the initial setup of objects
/// </summary>
public bool Populate(NetWorker socket)
{
List <SimpleNetworkedMonoBehavior> allBehaviors = new List <SimpleNetworkedMonoBehavior>(startNetworkedSceneBehaviors);
// Find all objects in the scene that have SNMB
SimpleNetworkedMonoBehavior[] behaviors = FindObjectsOfType <SimpleNetworkedMonoBehavior>();
foreach (SimpleNetworkedMonoBehavior behavior in behaviors)
{
if (!allBehaviors.Contains(behavior))
{
allBehaviors.Add(behavior);
}
}
if (Networking.Sockets == null)
{
Debug.LogWarning("No connection has been established for this network scene, preparing offline play...");
IsSetup = true;
foreach (Action execute in setupActions)
{
execute();
}
return(false);
}
ControllingSocket = socket;
OwningNetWorker = ControllingSocket;
if (!OwningNetWorker.Connected)
{
NetWorker.BasicEvent handler = null;
handler = () =>
{
SetupObjects(allBehaviors.ToArray(), OwningNetWorker);
foreach (Action execute in setupActions)
{
execute();
}
OwningNetWorker.connected -= handler;
};
OwningNetWorker.connected += handler;
}
else
{
SetupObjects(allBehaviors.ToArray(), OwningNetWorker);
foreach (Action execute in setupActions)
{
execute();
}
}
OwningNetWorker.AddCustomDataReadEvent(WriteCustomMapping.NETWORKING_MANAGER_POLL_PLAYERS, PollPlayersResponse, true);
return(true);
}
protected override void OwnerUpdate()
{
base.OwnerUpdate();
if (Input.GetKeyDown(KeyCode.O))
{
RPC("TestRPC", NetworkReceivers.Others);
}
if (Input.GetKeyDown(KeyCode.B))
{
AssignName("Brent");
}
else if (Input.GetKeyDown(KeyCode.F))
{
AssignName("Farris");
}
if (Input.GetKey(KeyCode.UpArrow))
{
transform.position += Vector3.up * 5.0f * Time.deltaTime;
}
if (Input.GetKey(KeyCode.DownArrow))
{
transform.position += Vector3.down * 5.0f * Time.deltaTime;
}
if (Input.GetKey(KeyCode.LeftArrow))
{
transform.position += Vector3.left * 5.0f * Time.deltaTime;
}
if (Input.GetKey(KeyCode.RightArrow))
{
transform.position += Vector3.right * 5.0f * Time.deltaTime;
}
if (Input.GetKeyDown(KeyCode.T))
{
cachedData = ServerSerialze(testNum++);
Networking.WriteCustom(SERVER_ONLY, Networking.PrimarySocket, cachedData, true, NetworkReceivers.Server);
}
if (Input.GetKeyDown(KeyCode.Space))
{
number++;
cat += "Cat";
}
else if (Input.GetKeyDown(KeyCode.V))
{
floatNumber += 50.35f;
}
if (Input.GetKeyDown(KeyCode.S))
{
BeardedManStudios.Network.Cache.Set <int>("test", 9);
}
if (Input.GetKeyDown(KeyCode.G))
{
BeardedManStudios.Network.Cache.Request <int>("test", (object x) =>
{
Debug.Log(x);
});
}
if (OwningNetWorker.IsServer && Input.GetKeyDown(KeyCode.N))
{
Networking.ChangeClientScene(OwningNetWorker, "ForgeWriteCustom");
#if UNITY_4_6 || UNITY_4_7
Application.LoadLevel("ForgeWriteCustom");
#else
Network.Unity.UnitySceneManager.LoadScene("ForgeWriteCustom");
#endif
}
else if (OwningNetWorker.IsServer && Input.GetKeyDown(KeyCode.M))
{
Networking.ChangeClientScene(OwningNetWorker, "ForgeHelloCubeResources");
#if UNITY_4_6 || UNITY_4_7
Application.LoadLevel("ForgeHelloCubeResources");
#else
Network.Unity.UnitySceneManager.LoadScene("ForgeHelloCubeResources");
#endif
}
if (Input.GetKeyDown(KeyCode.L))
{
dontLerp += 5.35f;
}
if (Input.GetKeyDown(KeyCode.C))
{
RPC("MessageGroupTest", NetworkReceivers.MessageGroup, (byte)9);
}
if (Input.GetKeyDown(KeyCode.Alpha0))
{
Debug.Log("Setting message group to 0");
Networking.SetMyMessageGroup(OwningNetWorker, (ushort)0);
}
else if (Input.GetKeyDown(KeyCode.Alpha1))
{
Debug.Log("Setting message group to 1");
Networking.SetMyMessageGroup(OwningNetWorker, (ushort)1);
}
else if (Input.GetKeyDown(KeyCode.Alpha2))
{
Debug.Log("Setting message group to 2");
Networking.SetMyMessageGroup(OwningNetWorker, (ushort)2);
}
else if (Input.GetKeyDown(KeyCode.Alpha3))
{
Debug.Log("Setting message group to 3");
Networking.SetMyMessageGroup(OwningNetWorker, (ushort)3);
}
if (OwningNetWorker.IsServer && Input.GetKeyDown(KeyCode.U))
{
AuthoritativeRPC("AuthMessage", OwningNetWorker, OwningNetWorker.Players[0], true, "World");
}
if (OwningNetWorker.IsServer && Input.GetKeyDown(KeyCode.L))
{
OwningNetWorker.BanPlayer(OwningNetWorker.Players[0], 500);
}
if (Input.GetKeyDown(KeyCode.Escape))
{
Networking.Disconnect();
#if UNITY_4_6 || UNITY_4_7
Application.LoadLevel(0);
#else
Network.Unity.UnitySceneManager.LoadScene(0);
#endif
}
}
