using UnityEngine;
using System.Collections;
using CustomTool;

public class Weapon : MonoBehaviour
{
private TimerItem                _timerReload;

private int                   _cadence = 1;
private float                   _tmpCadence = 0;

private void Start()
{
   _timerReload = Timer.Singletone.QuickTimer (1, false, true);
   ReloadEventSetup ();
}

private void Update()
{
   if(Input.GetKeyDown(KeyCode.R))
   {
      _timerReload.Start ();
   }

   if (Input.GetMouseButton (0) && !_timerReload.IsRuning) 
   {
      if (_checkCadence)
      {
         Shot ();
      }
   }
}


private bool _checkCadence{get{ if(_tmpCadence < Time.time){ _tmpCadence = _cadence + Time.time; return true; } else return false; }}

public virtual void Shot()
{
   print ("shoting");
}

public virtual void Reload()
{      
   print ("Finish Reload");
}

private void ReloadEventSetup()
{
   _timerReload.EventStart += () => 
   {
      print ("start reloading");
   };

   _timerReload.EventFinish += () =>
   {
      Reload();
   };

   _timerReload.EventStop += () =>
   {
      
   };
}
}

private void Shot()
{
    Ray = Camera.Look;
    RaycastHit Hit;
    if(Raycast out Hit)
    {
        if(Hit == "Enemy")
        {
            Ejecuta Accion
        }
    }
}

public void Shot()
{
    Codigo de Disparo por RayCast, tomamos el net id y lo enviamos por commando
    Cmd_TakeDamage(hit.NetID); //EJEMPLO
}

[Command]
private void Cmd_TakeDamage(uint PlayerTake, int Damage)
{
    //buscamos los jugadores que corresponden al ID,con una simple funcion
    var otherp = FindPlayer(PlayerTake);
    if(otherp != null)
    {
        //llamamos la funcion de Take!
        otherp.playerHealt.HealtTake(50);
    }
}


private void FindPlayer(uint ID)
{
    foreach(var p in GameObject.FindObjectsOfType<PlayerControl>())
    {
        if(p.netId.Value = ID)
        {
            return p;
        }
    }
    return null;
}

public class PlayerControl : NetworkBehaviuor
{
    public PlayerHealt playerHealt;
    
    public override void OnStartClient()
    {
        playerHealt = GetComponent<PlayerHealt>();
    }
}

public class PlayerHealt : NetworkBehaviuor
{
    [SyncVar]
    int current = 100;

    [Server]
    internal void HealtTake(int value)
    {
        current -= value;
    }
}

public const int MaxHealt = 100;
[SyncVar]
public int Healt;

public delegate void d_Death();
[SyncEvent]
public event d_Death EventDeath;

[Client]
public void TakeDamage(int value)
{
    Healt -= value;
    Healt = Mathf.Clamp(Healt,0,MaxHealt);
}

[Client]
public void TakeCure(int value)
{
    Healt += value;
    Healt = Mathf.Clamp(Healt,0,MaxHealt);
}

1. Jamás un jugador va a poder infringir directamente daño a otro, de esto se encarga el servidor, pero existe una problemática, cuando nosotros ejecutamos un disparo, este evento es gestionado por el servidor, entonces es el Servidor en nombre de X Cliente dueño del disparo, supongamos que este impacta con otro jugador, ¿Quien resta la salud?, La respuesta es el Servidor. Es decir, si nosotros llamamos una funciona cualquiera desde un comando estamos haciéndolo en nombre del servidor.
   
   (CLIENTE) ---> Ejecuta ---> COMMAND ---> (SERVIDOR) ---> Ejecuta Funcion ---> TakeDamage();
    
2. Dicho lo anterior, podremos darnos cuanta de que no existe interacción Cliente/Cliente por lo que esto se denomina Cliente/Servidor. ¿Cual es realmente la problemática?, Aunque existan varios problemas relacionados solo con un sistema de salud, deberíamos destacar el mas importante. El Jugador local solo debe enviar su estado, no hay que confundir, es decir, el servidor no se debe de encargar de procesar si está muerto o no, para eso creamos nuestro sistema. Vi muchos errores a la hora de implementar funciones incoherentes, por ejemplo, que todos los jugadores comprueben si la salud es menor o igual a cero entonces esta muerto.
    

   void Update()
   {
       if(Healt <= 0)
       {
           IsDeath = true;
       }
   }

   Esto es un grave error, porque los tiempos de sincronización pueden variar según el Ping (Tiempo de Envío y Recibo de Datos) que el Cliente y servidor tengan. vamos a dar un Ejemplo: 
   Tenemos 4 Clientes en un servidor, Cliente 1 dispara y le quita 100 de salud al Cliente 2 Esta acción tomó un tiempo de.
   1- Cliente 1 (Enviar Datos del disparo al Servidor y Retornar Resultados) : 2s
   2- Cliente 2 (Recibe la noticia de que se le a impactado, el servidor llama a su función TakeDamage(), luego, el Cliente 2 envía los dato de su estado al Servidor) : 4s
   3- Clientes (Servidor Actualiza el Estado del Cliente 1 en todas las instancias del juego, diciendo que el valor de Healt es cero) 1s
   
   Vemos que en el Punto 1 el Cliente 1 ya sabe que le infligió daño al Cliente 2, pero aun el Cliente 2 no se enteró, suponiendo que el primer paso Duro solo 1s, ya que el segundo añadido es el tiempo que el Servidor tardó en enviar esa información al Cliente 1, el Cliente 2, por lo tanto recibe daño, y envía el valor de Healt al servidor, 4s + 1s que el servidor toma para enviar los datos de este evento al Cliente 3, 4 es el retardo que existiría, suponiendo así, que cada instancia debería comprobar aún si el Cliente 2 está vivo, pero qué pasa si en ese lapso de 4 segundo el Cliente 2 sobrevive, es decir, un ejemplo, lo reviven estilo BF, el Cliente 1,3,4 tendrían una mala información. en destiempo.
3. Aunque el ejemplo en cierta forma parece no tener coherencia el problema se presenta cuando múltiples clientes con distintos tiempos de respuestas se conectan al servidor, este error puede llegar a hacernos ver el jugador muerto disparando. 

[SyncVar]
internal bool IsDeath;
[SyncEvent]
public event d_Death EventDeath;

void Update()
{
    if(!isLocalPlayer)return;
    
    if(Healt <= 0 && !IsDeath)
    {
        IsDeath = true;
        if(EventDeath != null)EventDeath();
        Cmd_SendInfo(Healt,IsDeath);
    }
}

[Command]
private void Cmd_SendInfo(int healt, bool isDeath)
{
    Healt = healt;
    IsDeath = isDeath;
    if(IsDeath)if(EventDeath != null)EventDeath();
}

string Data = "100/0";

[Command]
private void Cmd_SendInfo(string data)
{
    string[] values = data.Split('/');
    Healt = int.Parse(values[0]);
    IsDeath = int.Parse(values[1])? false : true;
    Data = data;
}

[SyncVar]
public string Name;
[SyncVar]
public int Kills;
[SyncVar]
public int Deaths;
[SyncVar]
public int Score;

public void SetName(string value)
{
    Name = value;
    Cmd_SetName(value);
}

public void AddKill()
{
    Kills++;
    Cmd_AddKill(Kills);
}

public void AddDeath()
{
    Deaths++;
    Cmd_AddDeath(Deaths);
}

public void AddScore(int value)
{
    Score += value;
    Cmd_AddKill(Score);
}

[Command]
private void Cmd_SetName(string value)
{
    if(!isServer)return;
    Name = value;
}

[Command]
private void Cmd_AddKill(int value)
{
    if(!isServer)return;
    Kills = value;
}

[Command]
private void Cmd_AddDeath(int value)
{
    if(!isServer)return;
    Deaths = value;
}

[Command]
private void Cmd_AddScore(int value)
{
    if(!isServer)return;
    Score = value;
}

void OnGUI()
{
    foreach(PlayerInfo current in GameObject.FindObjectsOfType<PlayerInfo>())
    {
        if(current == this)GUI.color = Color.red;
        GUILayout.Box(current.Name + " D [" + current.Deaths + "] K [" + current.Kills + "] S [ " + current.Score + "]" );
    }
}

void Update()
{
    if(!isLocalPlayer)return; // Si no es el jugador Local Sale de la funcion UPDATE

    if(Input.GetMouseButtonDown(0))AddScore(100);
    if(Input.GetMouseButtonDown(1))AddKill();
    if(Input.GetMouseButtonDown(2))AddDeath();
}

Como dije al comienzo, espero que esto no sea solo un aporte de mi parte, si no que todos los que sepan y quieran aportar vayan anexando sus conocimiento, prácticas y ejemplos para poder entender mejor cómo armar nuestro propio juego en red..

PD: El post lo escribí todo desde la WEB pueden existir errores en la Sintaxis de la programacion. NO SE OLVIDEN DE PASAR POR MI CANAL DE YOUTUBE, DONDE SUBO TUTORIALES SOBRE UNITY