void uLink_OnPlayerConnected(uLink.NetworkPlayer player)
    {
        string loginName = player.loginData.Read<string> ();
        bool isSlayer = player.loginData.Read<bool> ();
        bool isVampire = player.loginData.Read<bool> ();

        if ( isSlayer == true )
        {
            uLink.Network.Instantiate (player, SlayerProxyPref, SlayerOwnerPref, SlayerCreatorPref, GetPosition('s'), SlayerSpawnLocation.rotation, 0, "SlayerPlayer");
            roundController.CurrentSlayerPlayerNumber++;

            GA.API.Design.NewEvent("New Slayer Player Connected");
        }
        else if ( isVampire == true )
        {

            uLink.Network.Instantiate (player, VampireProxyPref, VampireOwnerPref, VampireCreatorPref, GetPosition('v'), VampireSpawnLocation.rotation, 0, "VampirePlayer");
            roundController.CurrentVampirePlayerNumber++;

            GA.API.Design.NewEvent("New Vampire Player Connected");
        }

        if (!roundController.anybodyInTheGame)
            roundController.anybodyInTheGame = true;

        if( !roundController.roundStarted )
            if( ( roundController.CurrentSlayerPlayerNumber > 0 ) && ( roundController.CurrentVampirePlayerNumber > 0 ) )
            {
                roundController.roundStarted = true;
                roundController.StartTheRound();
            }
    }

// ReSharper disable once UnusedMember.Local
    protected void OwnerReceiveRemoteWantsStatusMessage(uLink.NetworkMessageInfo info)
    {
        if (networkView.isMine)
        {
            networkView.RPC("RemoteReceiveStatusMessage", info.sender, StatusMessage);
        }
    }

        public void uLink_OnPlayerConnected(uLink.NetworkPlayer player)
        {
            connectingPlayer = (NetUser)player.localData;
            String playerSteamURL = "http://steamcommunity.com/profiles/" + connectingPlayer.userID.ToString();

            WebClient wc = new WebClient ();
            wc.DownloadStringCompleted += (sender, e) =>
            {
                userProfilePage = e.Result;

                if (lockGroup != "none")
                {
                    if (userProfilePage.IndexOf("http://steamcommunity.com/groups/" + lockGroup) == -1)
                    {
                        connectingPlayer.Kick(NetError.Facepunch_Kick_Ban, true);
                    }
                }

                Match vacMatch = Regex.Match(userProfilePage, @"^([0-9]{1,5}) day\(s\) since last ban$");
                if (vacMatch.Success)
                {
                    int daysSinceBan = Convert.ToInt32(vacMatch.Groups[1].Value);
                    if (daysSinceBan < minVacDays)
                    {
                        connectingPlayer.Kick(NetError.Facepunch_Kick_Ban, true);
                    }
                }
            };

            wc.DownloadStringAsync(new Uri(playerSteamURL));
        }

 void uLink_OnHandoverTimeout(uLink.NetworkPlayer player)
 {
     //This code is needed to destroy the player object ([email protected]) in the new game server after the handover.
     //This code is executed if the client fails to connect to the new game server (for any reason).
     uLink.Network.DestroyPlayerObjects(player);
     uLink.Network.RemoveRPCs(player);
 }

// ReSharper disable once UnusedMember.Local
    protected void ReceiveSetConnectionQuality(float quality, uLink.NetworkMessageInfo info)
    {
        if (Server == null || networkView == null) return;
        if (info.sender == Server.networkView.owner || networkView.isMine)
        {
            _ConnectionQuality = quality;
        }
    }

    protected void uLink_OnNetworkInstantiate(uLink.NetworkMessageInfo info)
    {
        mainNetworkView = info.networkView;

        // override the instance's NetworkInsantiator Destroyer delegate.
        oldDestroyer = mainNetworkView.instantiator.destroyer;
        mainNetworkView.instantiator.destroyer = OverrideDestroyer;
    }

    void uLink_OnNetworkInstantiate(uLink.NetworkMessageInfo msg)
    {
        Color color = msg.networkView.initialData.Read<Color>();
        string name = msg.networkView.initialData.Read<string>();

        BroadcastMessage("SetLabel", name, SendMessageOptions.DontRequireReceiver);
        BroadcastMessage("SetColor", color, SendMessageOptions.DontRequireReceiver);
    }

    void uLink_OnNetworkInstantiate(uLink.NetworkMessageInfo msg)
    {
        uLink.NetworkPlayer myPlayer = uLink.Network.player;
        myPlayer.localData = this;

        playerColor = msg.networkView.initialData.Read<Color>();
        playerName = msg.networkView.initialData.Read<string>();

        BroadcastMessage("SetColor", playerColor, SendMessageOptions.DontRequireReceiver);
    }

    void uLink_OnPlayerConnected(uLink.NetworkPlayer player)
    {
        string loginName;
        if (!player.loginData.TryRead<string>(out loginName)) loginName = "Nameless";

        //Instantiates an avatar for the player connecting to the server
        //The player will be the "owner" of this object. Read the manual chapter 7 for more
        //info about object roles: Creator, Owner and Proxy.
        uLink.Network.Instantiate(player, proxyPrefab, ownerPrefab, creatorPrefab, spawnLocation.transform.position, spawnLocation.transform.rotation, 0, loginName);
    }

 public void Set(IDMain idMain, ref Vector3 localPoint, ref Angle2 localNormal, byte bodyPart, ref uLink.NetworkMessageInfo info)
 {
     if (!(idMain is Character))
     {
         this.Set(idMain.GetRemote<HitBoxSystem>(), ref localPoint, ref localNormal, bodyPart, ref info);
     }
     else
     {
         this.Set((Character)idMain, ref localPoint, ref localNormal, bodyPart, ref info);
     }
 }

 void uLink_OnNetworkInstantiate(uLink.NetworkMessageInfo info)
 {
     int ownerViewId = info.networkView.initialData.Read<int>();
     uLink.NetworkView slingshotNetworkView = uLink.NetworkView.Find(new uLink.NetworkViewID(ownerViewId));
     slingshot = slingshotNetworkView.GetComponentInChildren<SlingshotOwner>();
     slingshot.SetProjectile(this);
     smoothRigidbody = GetComponent<uLinkSmoothRigidbodyImproved>();
     disablePhysics();
     transform.parent = slingshot.transform;
     transform.position = slingshot.transform.position;
 }

    void uLink_OnPlayerConnected(uLink.NetworkPlayer player)
    {
        Debug.Log("OnPlayerConnected() " + player.ipAddress + ":" + player.port);

        bool grounded = GameController.Player.GetComponent<Animator>().GetBool(Registry.Animator.Grounded);
        if(grounded)
        {
            GameController.Player.GetComponent<PlayerSync>().SendTrigger(Registry.Animator.Land);
            GameController.Player.GetComponent<PlayerSync>().SendBool(Registry.Animator.Grounded, grounded);
        }
    }

    void uLink_OnPlayerDisconnected(uLink.NetworkPlayer player)
    {
        if (cleanupAfterPlayers)
        {
            uLink.Network.DestroyPlayerObjects(player);
            uLink.Network.RemoveRPCs(player);

            // this is not really necessery unless you are removing NetworkViews without calling uLink.Network.Destroy
            uLink.Network.RemoveInstantiates(player);
        }
    }

 private void uLink_OnNetworkInstantiate(uLink.NetworkMessageInfo info)
 {
     if (base.networkView.isMine)
     {
         this.uspeaker.SpeakerMode = SpeakerMode.Local;
     }
     else
     {
         this.uspeaker.SpeakerMode = SpeakerMode.Remote;
     }
 }

 private void base_OnPlayerDisconnected(uLink.NetworkPlayer player)
 {
     // Delay removing player until OnPlayerDisconnect has fired in plugin
     if (player.GetLocalData() is NetUser)
     {
         NextTick(() =>
         {
             foreach (var plugin_field in onlinePlayerFields) plugin_field.Call("Remove", player);
         });
     }
 }

    public void Connect(uLink.HostData hostData, string playerName)
    {
        isRedirected = false;

        uLink.NetworkConnectionError error = uLink.Network.Connect(hostData, "", playerName);

        if (error != uLink.NetworkConnectionError.NoError)
        {
            SendMessage("uLink_OnFailedToConnect", error);
        }
    }

    void uLink_OnPreStartNetwork(uLink.NetworkStartEvent nsEvent)
    {
        general.Override();

        switch (nsEvent)
        {
            case uLink.NetworkStartEvent.Client: client.Override(); break;
            case uLink.NetworkStartEvent.Server: server.Override(); break;
            case uLink.NetworkStartEvent.CellServer: cellServer.Override(); break;
            case uLink.NetworkStartEvent.MasterServer: masterServer.Override(); break;
        }
    }

 private void OverrideDestroyer(uLink.NetworkView instance)
 {
     if (autoDestroyAfterMessage)
     {
         instance.BroadcastMessage(broadcastMessage, SendMessageOptions.DontRequireReceiver);
         Destroy();
     }
     else
     {
         // if we're relying on the message receiver for cleanup, then make sure there is one.
         instance.BroadcastMessage(broadcastMessage, SendMessageOptions.RequireReceiver);
     }
 }

 protected override bool OnRPC(string rpcName, uLink.BitStream stream, uLink.NetworkMessageInfo info)
 {
     string str;
     char chr = rpcName[0];
     if (!NGCInternalView.Hack.actionToRPCName.TryGetValue(chr, out str))
     {
         Dictionary<char, string> chrs = NGCInternalView.Hack.actionToRPCName;
         string str1 = string.Concat("NGC:", chr);
         str = str1;
         chrs[chr] = str1;
     }
     return base.OnRPC(str, stream, info);
 }

    // BitStream Reader
    public static object ReadFromBitStream(uLink.BitStream stream, params object[] args)
    {
        RankEntry myObj = new RankEntry();

        //myObj.rankIndex = stream.ReadInt32();
        //myObj.accountId = stream.ReadString();
        myObj.name = stream.ReadString();
        myObj.country = stream.ReadString();
        myObj.bestRanking = stream.ReadInt32();
        //myObj.totalDamage = stream.ReadInt64();

        return myObj;
    }