RPC call failed

When I click the spawn button in my multiplayer game this error shows up.

1. RPC call failed because the function '­Client_PlayerAlive' does not exist in the any script attached to'PlayerManager'

2. UnityEngine.NetworkView:RPC(String, RPCMode, Object[])

3. MultiplayerManager:Client_SpawnPlayer(NetworkPlayer, Vector3, Quaternion) (at Assets/Scripts/MultiplayerManager.cs:180)

4. UnityEngine.NetworkView:RPC(String, RPCMode, Object[])

5. MultiplayerManager:Server_SpawnPlayer(NetworkPlayer) (at Assets/Scripts/MultiplayerManager.cs:168)

6. MultiplayerManager:SpawnMenu() (at Assets/Scripts/MultiplayerManager.cs:223)

7. MultiplayerManager:OnGUI() (at Assets/Scripts/MultiplayerManager.cs:155)

MultiplayerManager

 using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
 
 public class MultiplayerManager : MonoBehaviour 
 {
     public static MultiplayerManager instance;
     public GUIManager guiManager;
     
     public GameObject PlayerManagerPrefab;
         
     public string PlayerName;
     
     private string MatchName = "";
     private string MatchPassword = "";
     private int MatchMaxUsers = 32;
     
     public List<MPPlayer> PlayerList = new List<MPPlayer>();
     public List<MapSetting> MapList = new List<MapSetting>();
     
     public MapSetting CurrentMap = null;
     public int oldprefix;
     public bool IsMatchStarted = false;
     
     //General Multiplayer Modes
     public bool MatchLoaded;
     public MPPlayer MyPlayer;
     public GameObject[] SpawnPoints;
         
     void Start()
     {
         DontDestroyOnLoad(gameObject);
         instance = this;
         PlayerName = PlayerPrefs.GetString("PlayerName");
         CurrentMap = MapList[0];
     }
     
     void FixedUpdate()
     {
         instance = this;
     }
     
     void Update()
     {
     }
     
     public void StartServer(string servername, string serverpassword, int maxusers)
     {
         MatchName = servername;
         MatchPassword = serverpassword;
         MatchMaxUsers = maxusers;
         Network.InitializeServer(MatchMaxUsers, 2550, false);
         Network.InitializeSecurity();
         MasterServer.RegisterHost("DeathMatch", MatchName, "");
     }
     
     void OnServerInitialized()
     {
         Server_PlayerJoinRequest(PlayerName, Network.player);
     }
     
     void OnConnectedToServer()
     {
         networkView.RPC("Server_PlayerJoinRequest", RPCMode.Server, PlayerName, Network.player);
     }
     
     void OnPlayerDisconnected(NetworkPlayer id)
     {
         networkView.RPC("Client_RemovePlayer", RPCMode.All, id);    
     }
     
     void OnPlayerConnected(NetworkPlayer player)
     {
         foreach(MPPlayer pl in PlayerList)
         {
             networkView.RPC("Client_AddPlayerToList", player, pl.PlayerName, pl.PlayerNetwork);
         }
             networkView.RPC("Client_GetMultiplayerMatchSettings", player, CurrentMap.MapName, "", "");
     }
     
     void OnDisconnectedFromServer()
     {
         PlayerList.Clear();
     }
     
     [RPC]
     void Server_PlayerJoinRequest(string playername, NetworkPlayer view)
     {
         networkView.RPC("Client_AddPlayerToList", RPCMode.All, playername, view);
     }
     
     [RPC]
     void Client_AddPlayerToList(string playername, NetworkPlayer view)
     {
         MPPlayer tempplayer = new MPPlayer();
         tempplayer.PlayerName = playername;
         tempplayer.PlayerNetwork = view;
         PlayerList.Add(tempplayer);
         if(Network.player == view)
         {
             MyPlayer = tempplayer;
             GameObject play = Network.Instantiate(PlayerManagerPrefab, Vector3.zero, Quaternion.identity, 5) as GameObject;
         }
     }
     
     [RPC]
     void Client_RemovePlayer(NetworkPlayer view)
     {
         MPPlayer temppl = null;
         foreach(MPPlayer pl in PlayerList)
         {
             if(pl.PlayerNetwork == view)
             {
                 temppl = pl;
             }
         }
         if (temppl != null)
         {
             PlayerList.Remove(temppl);
         }
     }
     
     [RPC]
     void Client_GetMultiplayerMatchSettings(string map, string mode, string others)
     {
         CurrentMap = GetMap(map);
     }
     
     public MapSetting GetMap(string name)
     {
         MapSetting get = null;
         
         foreach(MapSetting st in MapList)
         {
             if(st.MapName == name)
             {
                 get = st;
                 break;
             }
         }
         
         return get;
     }
     
     [RPC]
     void Client_LoadMultiplayerMap(string map, int prefix)
     {
         Network.SetLevelPrefix(prefix);
         Application.LoadLevel(map);
     }
     
     void OnGUI()
     {
         if(!MyPlayer.PlayerIsAlive && IsMatchStarted)
             SpawnMenu();
         
         if(IsMatchStarted && Input.GetKey(KeyCode.Tab))
         {
             guiManager.ScoreBoard();    
         }
     }
     
     [RPC]
     void Server_SpawnPlayer(NetworkPlayer player)
     {
         print("Sever spawn");
         int numberspawn = Random.Range(0, SpawnPoints.Length - 1);
         networkView.RPC("Client_SpawnPlayer", RPCMode.All, player, SpawnPoints[numberspawn].transform.position + new Vector3(0,2,0), SpawnPoints[numberspawn].transform.rotation);
     }
     
     [RPC]
     void Client_SpawnPlayer(NetworkPlayer player, Vector3 position, Quaternion rotation)
     {
         MultiplayerManager.GetMPPlayer(player).PlayerIsAlive = true;
         MultiplayerManager.GetMPPlayer(player).PlayerHealth = 100;
         if(player == MyPlayer.PlayerNetwork)
         {
             MyPlayer.PlayerManager.ControllerTransform.position = position;
             MyPlayer.PlayerManager.ControllerTransform.rotation = rotation;
             MyPlayer.PlayerManager.networkView.RPC("­Client_PlayerAlive", RPCMode.All);
         }
         else
         {
             
         }
     }
     
     void OnLevelWasLoaded()
     {
         if(Application.loadedLevelName == CurrentMap.MapLoadName && Network.isServer)
         {
             MatchLoaded = true;
             SpawnPoints = GameObject.FindGameObjectsWithTag("spawnpoint");
             networkView.RPC("Client_ServerLoaded", RPCMode.AllBuffered, IsMatchStarted);
         }
     }
     
     [RPC]
     void Client_ServerLoaded(bool started)
     {
         MatchLoaded = true;
         IsMatchStarted = started;
     }
     
     public static MPPlayer GetMPPlayer(NetworkPlayer player)
     {
         foreach(MPPlayer play in MultiplayerManager.instance.PlayerList)
         {
             if(play.PlayerNetwork  == player)
             {
                 return play;
             }
         }
         return null;
     }
     
      //Deathmatch
     void SpawnMenu()
     {
        if(GUI.Button(new Rect(5, Screen.height -40, 250, 35),"Spawn"))
        {
          if(Network.isServer)
           Server_SpawnPlayer(Network.player);
          else
           networkView.RPC("Server_SpawnPlayer", RPCMode.Server, Network.player);
        }
     }
     
     [RPC]
     public void Client_UpdatePlayerHealthAndAlive(NetworkPlayer targetplayer, bool IsAlive, int CurrentHealth)
     {
         MPPlayer player = MultiplayerManager.GetMPPlayer(targetplayer);
         player.PlayerIsAlive = IsAlive;
         player.PlayerHealth = CurrentHealth;
     }
 }
 
 [System.Serializable]
 public class MPPlayer
 {
     public string PlayerName = "";
     public NetworkPlayer PlayerNetwork;
     public PlayerManager PlayerManager;
     public int PlayerHealth = 100;
     public bool PlayerIsAlive;
     public int PlayerScore;
     public int PlayerKills;
     public int PlayerDeaths;
 }
 
 [System.Serializable]
 public class MapSetting
 {
     public string MapName;
     public string MapLoadName;
     public Texture MapLoadTexture;
 }

PlayerManager

 using UnityEngine;
 using System.Collections;
 
 public class PlayerManager : MonoBehaviour {
 
     public MPPlayer thisplayer{
         get
         {
             return MultiplayerManager.GetMPPlayer(networkView.owner);
         }
     }
     public PlayerController Controller;
     public Transform ControllerTransform;
     
     public GameObject OutsideView;
     
     public Vector3 CurrentPosition;
     public Quaternion CurrentRotation;
     
     void Start()
     {
         ControllerTransform.gameObject.SetActive(false);
         OutsideView.SetActive(false);
         thisplayer.PlayerManager = this;
         DontDestroyOnLoad(gameObject);
     }
     
     void FixedUpdate()
     {
         if(networkView.isMine)
         {
             CurrentPosition = ControllerTransform.position;
             CurrentRotation = ControllerTransform.rotation;
         }
         else
         {
             OutsideView.transform.position = CurrentPosition + new Vector3(0,-0.1f,0);
             OutsideView.transform.rotation = CurrentRotation;
         }
     }
     
     void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
     {
          if (stream.isWriting) 
         {
           stream.Serialize(ref CurrentPosition);
             stream.Serialize(ref CurrentRotation);
         }
         else 
         {
             stream.Serialize(ref CurrentPosition);
             stream.Serialize(ref CurrentRotation);
         }
     }
     
     public void GetBulletDamage(int damage)
     {
         if(Network.isServer)
             Server_HandleBulletDamage(damage);
         else
         networkView.RPC("Server_HandleBulletDamage", RPCMode.Server, damage);
     }
     
     [RPC]
     public void Server_HandleBulletDamage(int damage)
     {
         thisplayer.PlayerHealth -= damage;
         if(thisplayer.PlayerHealth <= 0) //When dead
         {
             thisplayer.PlayerIsAlive = false;
             thisplayer.PlayerHealth = 0;
             networkView.RPC("Client_PlayerDead", RPCMode.All);
             MultiplayerManager.instance.networkView.RPC("Client_UpdatePlayerHealthAndAlive", RPCMode.Others, thisplayer.PlayerNetwork, false, 0);
         }
         else //When alive getting hit
         {
             MultiplayerManager.instance.networkView.RPC("Client_UpdatePlayerHealthAndAlive", RPCMode.All, thisplayer.PlayerNetwork, thisplayer.PlayerIsAlive, thisplayer.PlayerHealth);
         }
     }
     
     [RPC]
     public void Client_PlayerDead()
     {
         OutsideView.SetActive(false);
         if(networkView.isMine)
             ControllerTransform.gameObject.SetActive(false);
     }
     
     [RPC]
     public void Client_PlayerAlive()
     {
         print("Alive works");
         OutsideView.SetActive(true);
         if(networkView.isMine)
             ControllerTransform.gameObject.SetActive(true);
         else
             OutsideView.SetActive(true);
     }
 }