void Attacked(NetworkViewID id, NetworkViewID target, Vector3 hit)
    {
        GameObject attacker = NetworkView.Find(id).gameObject;
        GameObject other = NetworkView.Find(target).gameObject;
        LineRenderer line = attacker.GetComponent<LineRenderer>();

        line.enabled = true;
        line.SetPosition(1, hit);
        line.material.SetColor("_Color", Color.red);
        timer = 0;

        Collider[] effected = Physics.OverlapSphere(hit, explosionRad);

        if (Network.isServer)
        {
            for (int i = 0; i < effected.Length; i++)
            {
                //effected[i].gameObject.rigidbody.AddExplosionForce(explosionForce, hit, explosionRad);
            }
        }

        GameObject.Instantiate(explosionPrefab, hit, Quaternion.identity);

        if (id != target && other.networkView.isMine)
            other.GetComponent<CombatScript>().AlterHealth(-1);
    }

	void NetLightCampfire(NetworkViewID nvid, bool state) {
		if (nvid == networkView.viewID) {
			Flame.SetActive(state);
			Coals.SetActive(state);
			SFX.SetActive(state);
		}
	}

 public Player(NetworkPlayer _NetClient, NetworkViewID _NetViewID, PlayerInputDevice _LocalPlayerInput)
 {
     m_NetClient = _NetClient;
     m_NetViewID = _NetViewID;
     m_LocalPlayerInput = _LocalPlayerInput;
     m_PlayerInstance = null;
 }

 public void changeColor(Vector3 colorVector, NetworkViewID ID1, NetworkViewID ID2, NetworkViewID ID3)
 {
     Color color=new Color(colorVector.x,colorVector.y,colorVector.z);
     NetworkView.Find(ID1).renderer.material.color=color;
     NetworkView.Find(ID2).renderer.material.color=color;
     NetworkView.Find(ID3).renderer.material.color=color;
 }

 private void InstantiateTowerBulletOnClient(NetworkViewID bulletID)
 {
     TowerReloaderClient reloader = tower.GetComponent<TowerReloaderClient>();
     reloader.bullet = Instantiate(
         reloader.bulletPrefabClient, reloader.spawner.position, reloader.spawner.rotation) as Transform;
     reloader.bullet.networkView.viewID = bulletID;
 }

 public void OnPickUp(NetworkViewID owner, NetworkViewID parentId)
 {
     stoneRigidbody.isKinematic = true;
     gameObject.layer = 11;
     ParentToPlayerTransform(parentId);
     transform.localPosition = new Vector3(-0.35f,-0.35f,-1.0f);
 }

    void ChangePlayerCrystalColor(int aquiredType, NetworkViewID crystalPlayerID)
    {
        CrystalType crystal = (CrystalType)aquiredType;
        GameObject player = playerList.FindPlayer(ref crystalPlayerID);
        crystalRenderer = player.transform.Find("Animator").Find("Crystals").GetComponent<Renderer>();

        if (crystal == CrystalType.Strength) {
            crystalRenderer.material = crystalMaterials[0];

            gameObject.GetComponent<PlayerData>().color.x = crystalMaterials[0].color.r;
            gameObject.GetComponent<PlayerData>().color.y = crystalMaterials[0].color.g;
            gameObject.GetComponent<PlayerData>().color.z = crystalMaterials[0].color.b;
        }

        if (crystal == CrystalType.Wisdom) {
            crystalRenderer.material = crystalMaterials[1];

            gameObject.GetComponent<PlayerData>().color.x = crystalMaterials[1].color.r;
            gameObject.GetComponent<PlayerData>().color.y = crystalMaterials[1].color.g;
            gameObject.GetComponent<PlayerData>().color.z = crystalMaterials[1].color.b;
        }

        if (crystal == CrystalType.Hardness) {
            crystalRenderer.material = crystalMaterials[2];

            gameObject.GetComponent<PlayerData>().color.x = crystalMaterials[2].color.r;
            gameObject.GetComponent<PlayerData>().color.y = crystalMaterials[2].color.g;
            gameObject.GetComponent<PlayerData>().color.z = crystalMaterials[2].color.b;
        }
    }

    private void InstantiateBaseOnClient(NetworkViewID baseID)
    {
        gameBase = Instantiate(basePrefabClient, transform.position, transform.rotation) as Transform;
        gameBase.networkView.viewID = baseID;

        SetTeamInfoOnClient();
    }

	void SpawnPowerLocally(int type, Vector3 position, float angle, NetworkViewID optionalViewID){
		PowerSpawn requestedSpawn = new PowerSpawn();
		requestedSpawn.type = (PowerType)type;
		requestedSpawn.position = position;
		requestedSpawn.angle = angle;
		SpawnPowerLocally(requestedSpawn, optionalViewID);
	}

    void NetworkViewAllocator_ResponseViewID(NetworkViewID _viewID, string _requestID)
    {
        AllocationJob _allocationJob;

        if (! mAllocateRequests.TryGetValue(_requestID, out _allocationJob))
        {
            Debug.Log("The request has been canceled.");
            return;
        }

        var _networkView = _allocationJob.networkView;
        if (_networkView != null)
        {
            mAllocationBuffer[_requestID] = _viewID;
            _networkView.viewID = _viewID;
            if (_allocationJob.callback != null)
                _allocationJob.callback();
        }
        else
        {
            Debug.Log("Network viewID is allocated but target view does not exist anymore.");
        }

        mAllocateRequests.Remove(_requestID);
    }

 void ChangePlayerState(NetworkViewID viewID)
 {
     if(networkView.viewID == viewID) {
         this.transform.position = data.respawnPosition;
         data.stats.currentHealth = data.stats.maxHealth;
     }
 }

    public static void SetPlayerTeam(NetworkViewID playerID, int layer)
    {
        if (StopSend())
            return;

        Channel.networkView.RPC("SetPlayerTeamRPC", RPCMode.Others, playerID, layer);
    }

 void SendChatMessage(string msg, NetworkViewID player)
 {
     string sender = playerData.GetPlayerData(player).playerName;
     msg = sender + ": " + msg;
     chatBox.Add(msg);
     scrollPos.y = float.MaxValue;
 }

 void TryEnterVessel(NetworkViewID playerViewID)
 {
     if (!rider && !playerViewID.GetGameObject().GetComponent<VesselController>())
     {
         networkView.RPC("CommitEnterVessel", RPCMode.All, playerViewID);
     }
 }

 void CharacterSpawner_RequestSpawn(NetworkViewID _viewID, string _player, int _characterID, Vector3 _position)
 {
     //		Debug.Log("Spawn character network.");
     var _character = SpawnLocal(Global.Player()[_player], _characterID, _position);
     _character.networkView.enabled = true;
     _character.networkView.viewID = _viewID;
 }

    void addAllComponents(GameObject obj, NetworkViewID viewID, Vector3 coliderSize, Vector3 coliderCenter, AudioClip clip)
    {
        BoxCollider colider = obj.AddComponent<BoxCollider>();
        colider.size = coliderSize;
        colider.center = coliderCenter;

        AudioSource audio = obj.AddComponent<AudioSource>();
        audio.loop = true;

        audio.clip = clip;//clip;
        audio.enabled = false;

        UserManagementObjectController controller = obj.AddComponent<UserManagementObjectController> ();
        controller.accessGrantedName = "player2";
        //RPC Methode unten vielleicht
        //this.networkView.RPC("setAccessGrantedPlayer", RPCMode.Server, 0);
        controller.setAccessGrantedPlayer ();

        NetworkView net = obj.AddComponent<NetworkView> ();
        net.observed = controller;

        net.viewID = viewID;

        Rigidbody rigid = obj.AddComponent<Rigidbody> ();
        rigid.useGravity = false;
        rigid.isKinematic = true;

        AnimationScript anime = obj.AddComponent<AnimationScript> ();
        anime.currentGameObj = obj;
        anime.enabled = false;

        obj.AddComponent<MeshRenderer> ();
    }

    public override bool controlSelectedObjects(bool select, NetworkViewID viewID, NetworkMessageInfo info)
    {
        if (isObjectAccessGranted(info.sender))
        {
            if (base.controlSelectedObjects(select,viewID,info))
            {
                /* ------------------ VRUE Tasks START   -------------------
                 *	- set the current NetworkPlayer to the player calling the RPC-method or
                 *	the default NetworkPlayer depending on "select"
                ----------------------------------------------------------------- */

                //return true;//replace me

                if (select)
                {
                    currentAccessPlayer = info.sender;
                }
                else
                {
                    currentAccessPlayer = defaultAccessPlayer;
                }
                return true;

                // ------------------ VRUE Tasks END ----------------------------

            }
        }
        return false;
    }

	public void OnSetposition(Vector3 pos, NetworkViewID id){
		if(id==Player.GetComponent<NetworkView>().viewID){
			Player.GetComponent<NavMeshAgent>().SetDestination(pos);
			Debug.Log("receved pos message");
		}
			
	}

 public void RPCAddNetworkView(NetworkViewID id)
 {        
     NetworkView nw = this.gameObject.AddComponent<NetworkView>();
     nw.group = (int)Group.RPCAssignID;
     nw.observed = null;
     nw.stateSynchronization = NetworkStateSynchronization.ReliableDeltaCompressed;
     nw.viewID = id;
 }

 private void SetCube(NetworkViewID id, float amountRed, float amountBlue)
 {
     GameObject cube = NetworkView.Find(id).gameObject;
     PG_Cube cubeScript = cube.GetComponent<PG_Cube>();
     cubeScript.amountRed = amountRed;
     cubeScript.amountBlue = amountBlue;
     cubeScript.SetColor(null);
 }