Character Controll;

public float hareketHizi;
 public float ziplama;
 public GameObject kamera;
 public GameObject kapsul;
 public float kameraAcisi;
 void Start () {
 }

 void Update () {
     KarakterHareket();
     KameraKontrol();
 }
 void KameraKontrol()
 {
     float x = Input.GetAxis("Mouse X");
     float y = Input.GetAxis("Mouse Y");
     kapsul.transform.Rotate(new Vector3(0, 1, 0) * x);
     kameraAcisi -= y;
     kameraAcisi = Mathf.Clamp(kameraAcisi, -90, 90);
     kamera.transform.localEulerAngles = new Vector3(kameraAcisi, 0, 0);
 }
 void KarakterHareket()
 {
     float v = Input.GetAxis("Vertical");
     float h = Input.GetAxis("Horizontal");
     Vector3 yon = Vector3.Normalize(new Vector3(h, 0, v));
     transform.Translate(yon * hareketHizi * Time.deltaTime);

     if (Input.GetKeyDown(KeyCode.LeftShift))
     {
         hareketHizi = 8;
     }
     if (Input.GetKeyUp(KeyCode.LeftShift))
     {
         hareketHizi = 5;
     }
     RaycastHit ray;
     Physics.Raycast(transform.position, Vector3.down, out ray, Mathf.Infinity);
     if(ray.distance < 1.2f)
     {
         if (Input.GetKeyDown(KeyCode.Space))
         {
             GetComponent<Rigidbody>().AddForce(Vector3.up * ziplama);
         }
     }
 }


Connect Manager;

public static MaxPlayers m_InstanceMax = null;
 public static ModParty m_InstanceMod = null;
 public GameObject Room;
 public Transform[] spawnPoints;
 public GameObject myPlayer;
 [HideInInspector]
 public bool connect = false;
 [HideInInspector]
 public int ModParty;
 private byte Version = 1;
 public int PlayerMax = 10;
 /// <summary>if we don't want to connect in Start(), we have to "remember" if we called ConnectUsingSettings()</summary>
 private bool ConnectInUpdate = true;
 private bool Roomcreate = true;
 void Awake()
 {
     DontDestroyOnLoad(gameObject.transform);
 }
 void Start()
 {
     PhotonNetwork.autoJoinLobby = false;    // we join randomly. always. no need to join a lobby to get the list of rooms.

     SceneManager.sceneLoaded += (scene, loadscene) =>
     {
         if (SceneManager.GetActiveScene().name == "Game")
         {
             Spawn();
         }
     };
 }
 public virtual void Update()
 {
     if (ConnectInUpdate && connect && !PhotonNetwork.connected)
     {
         Debug.Log("Update() was called by Unity. Scene is loaded. Let's connect to the Photon Master Server. Calling: PhotonNetwork.ConnectUsingSettings();");
         ConnectInUpdate = false;
         PhotonNetwork.ConnectUsingSettings(Version + "." + SceneManagerHelper.ActiveSceneBuildIndex);
     }
 }
 public void Spawn()
 {
     int index = UnityEngine.Random.Range(0, spawnPoints.Length);
     myPlayer = PhotonNetwork.Instantiate("Player", spawnPoints[index].position, spawnPoints[index].rotation, 0);
 }
 // below, we implement some callbacks of PUN
 // you can find PUN's callbacks in the class PunBehaviour or in enum PhotonNetworkingMessage
 public virtual void OnConnectedToMaster()
 {
     Debug.Log("Cherche party en mode : "+ModParty);
     ExitGames.Client.Photon.Hashtable expectedProperties = new ExitGames.Client.Photon.Hashtable();
     expectedProperties.Add( RoomProperty.Type, ModParty.ToString());
     PhotonNetwork.JoinRandomRoom( expectedProperties, 0 );
 }
 public virtual void OnPhotonRandomJoinFailed()
 {
     Debug.Log("Aucune party, on en crée une.");
     RoomOptions roomOptions = new RoomOptions();
     roomOptions.maxPlayers = (byte)PlayerMax;
     roomOptions.customRoomProperties = new ExitGames.Client.Photon.Hashtable();
     roomOptions.customRoomProperties.Add( RoomProperty.Map, "Test" );
     roomOptions.customRoomProperties.Add( RoomProperty.Type, ModParty.ToString() );
     roomOptions.customRoomPropertiesForLobby = new string[] {
         RoomProperty.Map,
         RoomProperty.Type,
     };
     PhotonNetwork.CreateRoom ("TestMap" + "@" + Guid.NewGuid().ToString("N"), roomOptions, null);
     Roomcreate = true;
 }
 public void OnJoinedRoom()
 {
     Debug.Log("In Room");
     AutoFade.m_Instance.BeginFade (-1);
     Room.SetActive (true);
     Room.GetComponent<ManageListMembers> ().PlayerMax = PlayerMax;
     this.gameObject.SetActive (false);
     PhotonNetwork.playerName = ClickMenuMain.m_InstancePseudo.pseudo;
     m_InstanceMax = (new GameObject("maxplayers")).AddComponent<MaxPlayers>();
     m_InstanceMod = (new GameObject("modparty")).AddComponent<ModParty>();
     m_InstanceMax.maxplayers = PlayerMax;
     m_InstanceMod.modparty = ModParty;
 }


Weapon;

   private Animator anim;
    private AudioSource audioSource;

    public float range = 100f;
    public int bulletsPerMag = 30;
    public int bulletsLeft = 200;
    public int currentBullets;

    public enum ShootMode {Auto,Semi }
    public ShootMode shootingMode;

    public Transform shootPoint;
    public ParticleSystem muzzleFlash;
    public AudioClip shotSound;
    public AudioClip reloadSound;

    float damage = 20f;

    public GameObject hitParticles;
    public GameObject bulletImpact;

    public float fireRate = 0.08f;
    float fireTimer;

    private bool isReloading;
    private bool shootInput;
    private bool isAiming;

    private Vector3 originalPosition;
    public Vector3 aimPosition;
    public float aodSpeed;

    public float maxBulletSpreadAngle = 15.0f;

    void Start () {
        anim = GetComponent<Animator>();

        audioSource = GetComponent<AudioSource>();

        currentBullets = bulletsPerMag;

        originalPosition = transform.localPosition;
    }

    void Update () {

        switch (shootingMode)
        {
            case ShootMode.Auto:
                shootInput = Input.GetButton("Fire1");
                break;

            case ShootMode.Semi:
                shootInput = Input.GetButtonDown("Fire1");
                break;
        }

        if (shootInput)
        {
            if (currentBullets > 0)
            {
                Fire();
            }
            else if(bulletsLeft > 0 )
            {
                DoReload();
            }
        }

        if (Input.GetKeyDown(KeyCode.R))
        {
            if (currentBullets < bulletsPerMag && bulletsLeft > 0)
                DoReload();
        }

        if (fireTimer < fireRate)
            fireTimer += Time.deltaTime;

        AimDownSights();
    }

    private void AimDownSights()
    {
        if (Input.GetButton("Fire2"))
        {
            transform.localPosition = Vector3.Lerp(transform.localPosition, aimPosition, Time.deltaTime * aodSpeed);
            isAiming = true;
        }
        else
        {
            transform.localPosition = Vector3.Lerp(transform.localPosition, originalPosition, Time.deltaTime * aodSpeed);
            isAiming = false;
        }
    }

    void FixedUpdate()
    {
        AnimatorStateInfo info = anim.GetCurrentAnimatorStateInfo(0);

        isReloading = info.IsName("Reload");

        anim.SetBool("Aim", isAiming);
        //if (info.IsName("Shot")) anim.SetBool("Shot", false);
    }

    public void Fire()
    {
        if (fireTimer < fireRate || currentBullets <= 0 || isReloading) return;

        RaycastHit hit;

        Vector3 fireDirection = shootPoint.transform.forward;

        Quaternion fireRotation = Quaternion.LookRotation(fireDirection);

        Quaternion randomRotation = Random.rotation;

        fireRotation = Quaternion.RotateTowards(fireRotation, randomRotation, Random.Range(0.0f, maxBulletSpreadAngle));

        if (Physics.Raycast(shootPoint.position, fireRotation * Vector3.forward, out hit, range))
        {
            Health h = hit.transform.GetComponentInParent<Health>();

            if(h != null)
            {
                h.GetComponent<PhotonView>().RPC("TakeDamage", PhotonTargets.AllBuffered, damage);
            }

            Debug.Log(hit.transform.name + "found!");

            GameObject hitParticleEffect = Instantiate(hitParticles, hit.point, Quaternion.FromToRotation(Vector3.up, hit.normal));
            GameObject bulletHole = Instantiate(bulletImpact, hit.point, Quaternion.FromToRotation(Vector3.forward, hit.normal));

            Destroy(hitParticleEffect, 1f);
            Destroy(bulletHole, 2f);


        }
        anim.CrossFadeInFixedTime("Shot", 0.1f);
        muzzleFlash.Play();
        PlayShootSound();

        currentBullets--;
        fireTimer = 0.0f;
    }

    public void Reload()
    {
        if (bulletsLeft <= 0) return;

        int bulletsToLoad = bulletsPerMag - currentBullets;
        int bulletsToDeduct = (bulletsLeft >= bulletsToLoad) ? bulletsToLoad : bulletsLeft;

        bulletsLeft -= bulletsToDeduct;
        currentBullets += bulletsToDeduct;
    }

    private void DoReload()
    {
        AnimatorStateInfo info = anim.GetCurrentAnimatorStateInfo(0);

        if (isReloading) return;

        anim.CrossFadeInFixedTime("Reload", 0.01f);

        audioSource.PlayOneShot(reloadSound);

    }

    private void PlayShootSound()
    {
        audioSource.PlayOneShot(shotSound);
    }
}