using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using GameKitController.Audio;
using UnityEngine.Events;

#if UNITY_EDITOR
using UnityEditor;
#endif
public class simpleWeaponSystem : MonoBehaviour
{
    [Header ("Main Settings")]
    [Space]

    public weaponInfo weaponSettings;

    [Space]
    [Header ("Other Settings")]
    [Space]

    public AudioClip outOfAmmo;
    public AudioElement outOfAmmoAudioElement;
    public GameObject weaponProjectile;

    [Space]

    public LayerMask layer;

    public LayerMask targetForScorchLayer;

    public bool projectilesPoolEnabled = true;

    public int maxAmountOfPoolElementsOnWeapon = 30;

    public LayerMask targetToDamageLayer;

    [Space]

    public bool useCustomIgnoreTags;

    public List<string> customTagsToIgnoreList = new List<string> ();

    [Space]
    [Header ("Events Settings")]
    [Space]

    public bool sendProjectileEventOnFire;
    public eventParameters.eventToCallWithGameObject projectileEventOnFire;

    [Space]
    [Header ("Remote Events Settings")]
    [Space]

    public bool useRemoteEventOnObjectsFound;
    public List<string> remoteEventNameList = new List<string> ();

    public bool useRemoteEventOnObjectsFoundOnExplosion;
    public string remoteEventNameOnExplosion;

    [Space]
    [Header ("Debug")]
    [Space]

    public bool showDebugPrint;

    public bool holdShootActive;

    public bool reloading;
    public bool usingWeapon;

    public bool externalProjectileToFireAssigned;
    public GameObject externalProjectileToFire;

    [Space]
    [Header ("Components")]
    [Space]

    public Transform mainCameraTransform;

    public AudioSource weaponsEffectsSource;

    public Camera mainCamera;

    public Animation weaponAnimation;

    public Collider playerCollider;

    public GameObject playerControllerGameObject;
    public GameObject playerCameraGameObject;
    public playerWeaponsManager mainPlayerWeaponsManager;

    public string mainDecalManagerName = "Decal Manager";

    public string mainNoiseMeshManagerName = "Noise Mesh Manager";

    public string [] impactDecalList;
    public int impactDecalIndex;
    public string impactDecalName;
    public bool getImpactListEveryFrame;

    decalManager impactDecalManager;

    List<GameObject> shells = new List<GameObject> ();
    float destroyShellsTimer = 0;
    RaycastHit hit;
    RaycastHit hitCamera;
    RaycastHit hitWeapon;
    float lastShoot;

    bool animationForwardPlayed;
    bool animationBackPlayed;

    bool shellCreated;

    bool weaponHasAnimation;

    Vector3 forceDirection;
    GameObject closestEnemy;

    float weaponSpeed = 1;
    float originalWeaponSpeed;

    Vector3 aimedZone;
    bool objectiveFound;

    bool usingSight;

    Coroutine muzzleFlashCoroutine;

    bool usingScreenSpaceCamera;
    bool targetOnScreen;
    Vector3 screenPoint;

    Rigidbody currentProjectileRigidbody;

    GameObject currentProjectile;

    projectileInfo newProjectileInfo;

    float screenWidth;
    float screenHeight;

    Transform currentProjectilePosition;

    projectileSystem currentProjectileSystem;

    List<projectileSystem> lastProjectilesSystemListFired = new List<projectileSystem> ();

    GameObject newShellClone;
    weaponShellSystem newWeaponShellSystem;
    AudioElement newClipToShell = new AudioElement ();
    GameObject currentShellToRemove;
    bool shellsActive;
    bool shellsOnSceneToRemove;

    GameObject newMuzzleParticlesClone;
    Coroutine reloadCoroutine;

    noiseMeshSystem noiseMeshManager;

    bool noiseMeshManagerFound;

    float currentRaycastDistance;

    bool surfaceFound;
    RaycastHit surfaceFoundHit;

    Coroutine holdShootWeaponCoroutine;

    bool mainPlayerWeaponsManagerLocated;


    private void InitializeAudioElements ()
    {
        weaponSettings.InitializeAudioElements ();

        if (outOfAmmo != null) {
            outOfAmmoAudioElement.clip = outOfAmmo;
        }
    }

    void Start ()
    {
        InitializeAudioElements ();

        weaponSettings.ammoPerClip = weaponSettings.clipSize;

        if (weaponSettings.startWithEmptyClip) {
            weaponSettings.clipSize = 0;
        }

        if (weaponSettings.animation != "") {
            weaponHasAnimation = true;
            weaponAnimation [weaponSettings.animation].speed = weaponSettings.animationSpeed;
        } else {
            shellCreated = true;
        }

        originalWeaponSpeed = weaponSpeed;

        weaponSettings.auxRemainAmmo = weaponSettings.remainAmmo;

        mainPlayerWeaponsManagerLocated = mainPlayerWeaponsManager != null;

        if (mainPlayerWeaponsManagerLocated) {
            usingScreenSpaceCamera = mainPlayerWeaponsManager.isUsingScreenSpaceCamera ();
        }

        currentRaycastDistance = Mathf.Infinity;
    }

    void Update ()
    {
        if (!shellCreated && ((weaponHasAnimation && animationForwardPlayed && !weaponAnimation.IsPlaying (weaponSettings.animation)) || !weaponHasAnimation)) {
            createShells ();
        }

        if (!reloading) {
            if (weaponHasAnimation) {
                if (weaponSettings.clipSize > 0) {
                    if (weaponSettings.playAnimationBackward) {
                        if (animationForwardPlayed && !weaponAnimation.IsPlaying (weaponSettings.animation)) {
                            animationForwardPlayed = false;
                            animationBackPlayed = true;

                            weaponAnimation [weaponSettings.animation].speed = -weaponSettings.animationSpeed;

                            weaponAnimation [weaponSettings.animation].time = weaponAnimation [weaponSettings.animation].length;

                            weaponAnimation.Play (weaponSettings.animation);
                        }
                        if (animationBackPlayed && !weaponAnimation.IsPlaying (weaponSettings.animation)) {
                            animationBackPlayed = false;
                        }
                    } else {
                        animationForwardPlayed = false;
                        animationBackPlayed = false;
                    }
                } else if ((weaponSettings.remainAmmo > 0 || weaponSettings.infiniteAmmo) && weaponSettings.autoReloadWhenClipEmpty) {
                    reloadWeapon (weaponSettings.reloadDelayThirdPerson);
                }
            } else {
                if (weaponSettings.clipSize == 0) {
                    if ((weaponSettings.remainAmmo > 0 || weaponSettings.infiniteAmmo) && weaponSettings.autoReloadWhenClipEmpty) {
                        reloadWeapon (weaponSettings.reloadDelayThirdPerson);
                    }
                }
            }
        }

        checkDroppedShellsRemoval ();
    }

    public void shootWeaponExternally ()
    {
        inputShootWeaponOnPressDown ();

        inputShootWeaponOnPressUp ();
    }

    void setHoldShootWeaponState (bool state)
    {
        stopUpdateHoldShootWeaponCoroutine ();

        if (state) {
            holdShootWeaponCoroutine = StartCoroutine (updateHoldShootWeaponCoroutine ());

            holdShootActive = true;

            if (showDebugPrint) {
                print ("holdShootActive as true");
            }
        }
    }

    public void stopUpdateHoldShootWeaponCoroutine ()
    {
        if (holdShootWeaponCoroutine != null) {
            StopCoroutine (holdShootWeaponCoroutine);
        }

        if (holdShootActive) {
            shootWeapon (false);
        }

        holdShootActive = false;

        if (showDebugPrint) {
            print ("holdShootActive as false");
        }
    }

    IEnumerator updateHoldShootWeaponCoroutine ()
    {
        var waitTime = new WaitForFixedUpdate ();

        while (true) {
            yield return waitTime;

            shootWeapon (true);
        }
    }


    public void inputHoldOrReleaseShootWeapon (bool holdingButton)
    {
        if (holdingButton) {
            setHoldShootWeaponState (true);
        } else {
            setHoldShootWeaponState (false);
        }
    }

    public void inputShootWeaponOnPressDown ()
    {
        shootWeapon (true);
    }

    public void inputShootWeaponOnPressUp ()
    {
        shootWeapon (false);
    }

    public void inputShootWeaponOnPress ()
    {
        if (weaponSettings.automatic) {
            shootWeapon (true);
        }
    }

    public void shootWeapon (bool state)
    {
        if (mainPlayerWeaponsManagerLocated) {
            if (state) {
                shootWeapon (!mainPlayerWeaponsManager.isFirstPersonActive (), state);
            } else {
                shootWeapon (!mainPlayerWeaponsManager.isFirstPersonActive (), state);
            }
        } else {
            shootWeapon (true, state);
        }
    }

    public void addExternalProjectileToFire (GameObject newProjectile)
    {
        externalProjectileToFire = newProjectile;

        externalProjectileToFireAssigned = externalProjectileToFire != null;
    }

    public void removeExternalProjectileToFire (GameObject newProjectile)
    {
        if (externalProjectileToFire != null && externalProjectileToFire == newProjectile) {
            addExternalProjectileToFire (null);
        }
    }

    public void sendRemoteEventToExternalProjectile (string remoteEventName)
    {
        if (externalProjectileToFire != null) {
            externalProjectileToFire.GetComponent<projectileSystem> ().checkRemoteEventOnProjectile (remoteEventName);
        }
    }

    Transform currentMainCameraTransform;

    //fire the current weapon
    public void shootWeapon (bool isThirdPersonView, bool shootAtKeyDown)
    {
        checkWeaponAbility (shootAtKeyDown);

        //if the weapon system is active and the clip size higher than 0
        if (weaponSettings.clipSize > 0) {
            //else, fire the current weapon according to the fire rate
            if (Time.time > lastShoot + weaponSettings.fireRate) {

                if ((animationForwardPlayed || animationBackPlayed) && weaponHasAnimation) {
                    return;
                }

                checkWeaponShootNoise ();

                //play the fire sound
                playWeaponSoundEffect (true);

                //enable the muzzle flash light
                enableMuzzleFlashLight ();

                if (useCustomMainCameraTransformActive) {
                    currentMainCameraTransform = customMainCameraTransform;
                } else {
                    currentMainCameraTransform = mainCameraTransform;
                }

                Vector3 mainCameraPosition = currentMainCameraTransform.position;

                //create the muzzle flash
                createMuzzleFlash ();

                bool weaponCrossingSurface = false;

                if (!isThirdPersonView) {
                    if (weaponSettings.checkCrossingSurfacesOnCameraDirection) {
                        if (weaponSettings.projectilePosition.Count > 0) {
                            if (Physics.Raycast (mainCameraPosition, currentMainCameraTransform.TransformDirection (Vector3.forward), out hitCamera, currentRaycastDistance, layer) &&
                                Physics.Raycast (weaponSettings.projectilePosition [0].position, currentMainCameraTransform.TransformDirection (Vector3.forward), out hitWeapon, currentRaycastDistance, layer)) {
                                if (hitCamera.collider != hitWeapon.collider) {
                                    //print ("too close surface");
                                    weaponCrossingSurface = true;
                                }
                            }
                        }
                    }
                }

                //play the fire animation
                if (weaponHasAnimation) {
                    weaponAnimation [weaponSettings.animation].speed = weaponSettings.animationSpeed;

                    weaponAnimation.Play (weaponSettings.animation);

                    animationForwardPlayed = true;

                    if (weaponSettings.cockSoundAudioElement != null) {
                        playSound (weaponSettings.cockSoundAudioElement);
                    }
                }

                shellCreated = false;

                Vector3 cameraDirection = currentMainCameraTransform.TransformDirection (Vector3.forward);

                lastProjectilesSystemListFired.Clear ();

                //every weapon can shoot 1 or more projectiles at the same time, so for every projectile position to instantiate
                for (int j = 0; j < weaponSettings.projectilePosition.Count; j++) {
                    currentProjectilePosition = weaponSettings.projectilePosition [j];

                    for (int l = 0; l < weaponSettings.projectilesPerShoot; l++) {

                        surfaceFound = false;

                        //create the projectile
                        if (externalProjectileToFireAssigned) {
                            if (externalProjectileToFire != null) {
                                externalProjectileToFire.transform.position = currentProjectilePosition.position;

                                externalProjectileToFire.transform.rotation = currentProjectilePosition.rotation;

                                currentProjectile = externalProjectileToFire;
                            } else {
                                externalProjectileToFireAssigned = false;
                            }
                        }

                        if (!externalProjectileToFireAssigned) {
                            if (projectilesPoolEnabled) {
                                currentProjectile = GKC_PoolingSystem.Spawn (weaponProjectile, currentProjectilePosition.position, currentMainCameraTransform.rotation, maxAmountOfPoolElementsOnWeapon);
                            } else {
                                currentProjectile = (GameObject)Instantiate (weaponProjectile, currentProjectilePosition.position, currentMainCameraTransform.rotation);
                            }
                        }

                        //set the info in the projectile, like the damage, the type of projectile, bullet or missile, etc...
                        currentProjectileSystem = currentProjectile.GetComponent<projectileSystem> ();

                        if (externalProjectileToFireAssigned) {
                            currentProjectileSystem.checkEventOnProjectileFiredExternally ();

                            externalProjectileToFire = null;

                            externalProjectileToFireAssigned = false;
                        }

                        currentProjectileSystem.checkToResetProjectile ();

                        lastProjectilesSystemListFired.Add (currentProjectileSystem);

                        if (!weaponSettings.launchProjectile) {
                            //set its direction in the weapon forward or the camera forward according to if the weapon is aimed correctly or not
                            if (!weaponCrossingSurface) {
                                if (weaponSettings.fireWeaponForward) {
                                    currentProjectile.transform.rotation = currentProjectilePosition.rotation;
                                } else {

                                    if (Physics.Raycast (mainCameraPosition, cameraDirection, out hit, currentRaycastDistance, layer)) {
                                        if (!hit.collider.isTrigger) {
                                            if (hit.collider != playerCollider) {
                                                //Debug.DrawLine (currentProjectilePosition.position, hit.point, Color.red, 2);

                                                currentProjectile.transform.LookAt (hit.point);

                                                surfaceFound = true;
                                                surfaceFoundHit = hit;
                                            } else {
                                                if (Physics.Raycast (hit.point + cameraDirection * 0.2f, cameraDirection, out hit, currentRaycastDistance, layer)) {
                                                    currentProjectile.transform.LookAt (hit.point);

                                                    surfaceFound = true;
                                                    surfaceFoundHit = hit;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        if (weaponSettings.launchProjectile) {
                            if (currentProjectileSystem != null) {
                                currentProjectileRigidbody = currentProjectileSystem.getProjectileRigibody ();
                            }

                            if (currentProjectileRigidbody == null) {
                                currentProjectileRigidbody = currentProjectile.GetComponent<Rigidbody> ();
                            }

                            currentProjectileRigidbody.isKinematic = true;
                            // If the vehicle has a gravity control component, and the current gravity is not the regular one,
                            // add an artificial gravity component to the projectile like this, it can make a parable in any
                            // surface and direction, setting its gravity in the same of the vehicle.

                            Vector3 currentNormal = Vector3.up;

                            if (mainPlayerWeaponsManagerLocated) {
                                currentNormal = mainPlayerWeaponsManager.getCurrentNormal ();
                            }

                            if (currentNormal != Vector3.up) {
                                currentProjectile.AddComponent<artificialObjectGravity> ().setCurrentGravity (-currentNormal);
                            }

                            if (weaponSettings.useParableSpeed) {
                                //get the ray hit point where the projectile will fall

                                //get the ray hit point where the projectile will fall
                                if (surfaceFound) {
                                    aimedZone = surfaceFoundHit.point;

                                    objectiveFound = true;
                                } else {
                                    if (Physics.Raycast (mainCameraPosition, cameraDirection, out hit, currentRaycastDistance, layer)) {
                                        if (hit.collider != playerCollider) {
                                            aimedZone = hit.point;

                                            objectiveFound = true;
                                        } else {
                                            if (Physics.Raycast (hit.point + cameraDirection * 0.2f, cameraDirection, out hit, currentRaycastDistance, layer)) {
                                                aimedZone = hit.point;

                                                objectiveFound = true;
                                            }
                                        }
                                    } else {
                                        objectiveFound = false;
                                    }
                                }
                            }

                            launchCurrentProjectile (currentProjectile, currentProjectileRigidbody, cameraDirection);
                        }

                        //add spread to the projectile
                        Vector3 spreadAmount = Vector3.zero;

                        if (weaponSettings.useProjectileSpread) {
                            spreadAmount = setProjectileSpread ();
                            currentProjectile.transform.Rotate (spreadAmount);
                        }

                        setProjectileInfo ();

                        currentProjectileSystem.setProjectileInfo (newProjectileInfo);

                        if (weaponSettings.isSeeker) {
                            closestEnemy = setSeekerProjectileInfo (currentProjectilePosition.position);

                            if (closestEnemy != null) {
                                currentProjectileSystem.setEnemy (closestEnemy);
                            }
                        }

                        bool projectileFiredByRaycast = false;

                        bool projectileDestroyed = false;

                        //if the weapon shoots setting directly the projectile in the hit point, place the current projectile in the hit point position
                        if (weaponSettings.useRayCastShoot || weaponCrossingSurface) {
                            Vector3 forwardDirection = currentMainCameraTransform.TransformDirection (Vector3.forward);
                            Vector3 forwardPosition = mainCameraPosition;

                            if (weaponSettings.fireWeaponForward && !weaponCrossingSurface) {
                                forwardDirection = transform.forward;
                                forwardPosition = currentProjectilePosition.position;
                            }

                            if (spreadAmount.magnitude != 0) {
                                forwardDirection = Quaternion.Euler (spreadAmount) * forwardDirection;
                            }

                            if (Physics.Raycast (forwardPosition, forwardDirection, out hit, currentRaycastDistance, layer)) {
                                if (hit.collider != playerCollider) {
                                    if (weaponSettings.useFakeProjectileTrails) {
                                        currentProjectileSystem.creatFakeProjectileTrail (hit.point);
                                    }

                                    currentProjectileSystem.rayCastShoot (hit.collider, hit.point, forwardDirection);

                                    projectileFiredByRaycast = true;
                                } else {
                                    if (Physics.Raycast (hit.point + forwardDirection * 0.2f, forwardDirection, out hit, currentRaycastDistance, layer)) {

                                        if (weaponSettings.useFakeProjectileTrails) {
                                            currentProjectileSystem.creatFakeProjectileTrail (hit.point);
                                        }

                                        currentProjectileSystem.rayCastShoot (hit.collider, hit.point, forwardDirection);

                                        projectileFiredByRaycast = true;
                                    }
                                }
                                //print ("same object fired: " + hit.collider.name);
                            } else {
                                currentProjectileSystem.initializeProjectile ();

                                currentProjectileSystem.destroyProjectile ();

                                projectileDestroyed = true;
                            }
                        }

                        if (!projectileFiredByRaycast && !projectileDestroyed) {
                            currentProjectileSystem.initializeProjectile ();
                        }
                    }

                    if (!weaponSettings.infiniteAmmo) {
                        useAmmo ();
                    }

                    lastShoot = Time.time;
                    destroyShellsTimer = 0;

                    checkSendProjectileOnEventFire ();
                }

                if (weaponSettings.weaponWithAbility) {
                    lastShoot = Time.time;
                    destroyShellsTimer = 0;
                }
            }
        }
        //else, the clip in the weapon is over, so check if there is remaining ammo
        else {
            if (weaponSettings.remainAmmo == 0 && !weaponSettings.infiniteAmmo) {
                playWeaponSoundEffect (false);
            }
        }
    }

    public void checkWeaponAbility (bool keyDown)
    {
        if (weaponSettings.weaponWithAbility) {
            if (keyDown) {
                if (weaponSettings.useDownButton) {
                    if (weaponSettings.downButtonAction.GetPersistentEventCount () > 0) {
                        weaponSettings.downButtonAction.Invoke ();
                    }
                }
            } else {
                if (weaponSettings.useUpButton) {
                    if (weaponSettings.upButtonAction.GetPersistentEventCount () > 0) {
                        weaponSettings.upButtonAction.Invoke ();
                    }
                }
            }
        }
    }

    bool newProjectileInfoCreated;

    bool projectileInfoAssigned;

    void setProjectileInfo ()
    {
        if (!newProjectileInfoCreated) {
            newProjectileInfo = new projectileInfo ();

            newProjectileInfoCreated = true;
        }

        if (useCustomMainCameraTransformActive) {
            newProjectileInfo.forwardDirection = customMainCameraTransform.forward;
        } else {
            newProjectileInfo.forwardDirection = mainCameraTransform.forward;
        }

        if (!projectileInfoAssigned) {
            newProjectileInfo.isHommingProjectile = weaponSettings.isHommingProjectile;

            newProjectileInfo.isSeeker = weaponSettings.isSeeker;
            newProjectileInfo.targetOnScreenForSeeker = weaponSettings.targetOnScreenForSeeker;

            newProjectileInfo.waitTimeToSearchTarget = weaponSettings.waitTimeToSearchTarget;
            newProjectileInfo.useRayCastShoot = weaponSettings.useRayCastShoot;

            newProjectileInfo.useRaycastShootDelay = weaponSettings.useRaycastShootDelay;
            newProjectileInfo.raycastShootDelay = weaponSettings.raycastShootDelay;
            newProjectileInfo.getDelayWithDistance = weaponSettings.getDelayWithDistance;
            newProjectileInfo.delayWithDistanceSpeed = weaponSettings.delayWithDistanceSpeed;
            newProjectileInfo.maxDelayWithDistance = weaponSettings.maxDelayWithDistance;

            newProjectileInfo.useFakeProjectileTrails = weaponSettings.useFakeProjectileTrails;

            newProjectileInfo.useRaycastCheckingOnRigidbody = weaponSettings.useRaycastCheckingOnRigidbody;
            newProjectileInfo.customRaycastCheckingRate = weaponSettings.customRaycastCheckingRate;
            newProjectileInfo.customRaycastCheckingDistance = weaponSettings.customRaycastCheckingDistance;

            if (mainPlayerWeaponsManagerLocated) {
                newProjectileInfo.projectileDamage = (weaponSettings.projectileDamage + mainPlayerWeaponsManager.getExtraDamageStat ()) * mainPlayerWeaponsManager.getDamageMultiplierStat ();
            } else {
                newProjectileInfo.projectileDamage = weaponSettings.projectileDamage;
            }

            newProjectileInfo.projectileSpeed = weaponSettings.projectileSpeed;

            newProjectileInfo.impactForceApplied = weaponSettings.impactForceApplied;
            newProjectileInfo.forceMode = weaponSettings.forceMode;
            newProjectileInfo.applyImpactForceToVehicles = weaponSettings.applyImpactForceToVehicles;
            newProjectileInfo.impactForceToVehiclesMultiplier = weaponSettings.impactForceToVehiclesMultiplier;

            newProjectileInfo.projectileWithAbility = weaponSettings.projectileWithAbility;

            newProjectileInfo.impactSoundEffect = weaponSettings.impactSoundEffect;
            newProjectileInfo.impactAudioElement = weaponSettings.impactAudioElement;

            newProjectileInfo.scorch = weaponSettings.scorch;
            newProjectileInfo.scorchRayCastDistance = weaponSettings.scorchRayCastDistance;

            newProjectileInfo.owner = playerControllerGameObject;

            newProjectileInfo.projectileParticles = weaponSettings.projectileParticles;
            newProjectileInfo.impactParticles = weaponSettings.impactParticles;

            newProjectileInfo.isExplosive = weaponSettings.isExplosive;
            newProjectileInfo.isImplosive = weaponSettings.isImplosive;
            newProjectileInfo.useExplosionDelay = weaponSettings.useExplosionDelay;
            newProjectileInfo.explosionDelay = weaponSettings.explosionDelay;
            newProjectileInfo.explosionForce = weaponSettings.explosionForce;
            newProjectileInfo.explosionRadius = weaponSettings.explosionRadius;
            newProjectileInfo.explosionDamage = weaponSettings.explosionDamage;
            newProjectileInfo.pushCharacters = weaponSettings.pushCharacters;
            newProjectileInfo.canDamageProjectileOwner = weaponSettings.canDamageProjectileOwner;
            newProjectileInfo.applyExplosionForceToVehicles = weaponSettings.applyExplosionForceToVehicles;
            newProjectileInfo.explosionForceToVehiclesMultiplier = weaponSettings.explosionForceToVehiclesMultiplier;

            newProjectileInfo.searchClosestWeakSpot = weaponSettings.searchClosestWeakSpot;

            newProjectileInfo.killInOneShot = weaponSettings.killInOneShot;

            newProjectileInfo.useDisableTimer = weaponSettings.useDisableTimer;
            newProjectileInfo.noImpactDisableTimer = weaponSettings.noImpactDisableTimer;
            newProjectileInfo.impactDisableTimer = weaponSettings.impactDisableTimer;

            newProjectileInfo.targetToDamageLayer = targetToDamageLayer;

            if (mainPlayerWeaponsManagerLocated) {
                newProjectileInfo.targetForScorchLayer = mainPlayerWeaponsManager.targetForScorchLayer;
            } else {
                newProjectileInfo.targetForScorchLayer = targetForScorchLayer;
            }

            newProjectileInfo.useCustomIgnoreTags = useCustomIgnoreTags;
            newProjectileInfo.customTagsToIgnoreList = customTagsToIgnoreList;

            newProjectileInfo.impactDecalIndex = impactDecalIndex;

            newProjectileInfo.launchProjectile = weaponSettings.launchProjectile;

            newProjectileInfo.adhereToSurface = weaponSettings.adhereToSurface;
            newProjectileInfo.adhereToLimbs = weaponSettings.adhereToLimbs;
            newProjectileInfo.ignoreSetProjectilePositionOnImpact = weaponSettings.ignoreSetProjectilePositionOnImpact;

            newProjectileInfo.useGravityOnLaunch = weaponSettings.useGravityOnLaunch;
            newProjectileInfo.useGraivtyOnImpact = weaponSettings.useGraivtyOnImpact;

            newProjectileInfo.breakThroughObjects = weaponSettings.breakThroughObjects;
            newProjectileInfo.infiniteNumberOfImpacts = weaponSettings.infiniteNumberOfImpacts;
            newProjectileInfo.numberOfImpacts = weaponSettings.numberOfImpacts;
            newProjectileInfo.canDamageSameObjectMultipleTimes = weaponSettings.canDamageSameObjectMultipleTimes;

            newProjectileInfo.ignoreNewRotationOnProjectileImpact = weaponSettings.ignoreNewRotationOnProjectileImpact;

            newProjectileInfo.canBreakThroughArmorSurface = weaponSettings.canBreakThroughArmorSurface;
            newProjectileInfo.breakThroughArmorSurfacePriorityValue = weaponSettings.breakThroughArmorSurfacePriorityValue;

            newProjectileInfo.damageTargetOverTime = weaponSettings.damageTargetOverTime;
            newProjectileInfo.damageOverTimeDelay = weaponSettings.damageOverTimeDelay;
            newProjectileInfo.damageOverTimeDuration = weaponSettings.damageOverTimeDuration;
            newProjectileInfo.damageOverTimeAmount = weaponSettings.damageOverTimeAmount;
            newProjectileInfo.damageOverTimeRate = weaponSettings.damageOverTimeRate;
            newProjectileInfo.damageOverTimeToDeath = weaponSettings.damageOverTimeToDeath;
            newProjectileInfo.removeDamageOverTimeState = weaponSettings.removeDamageOverTimeState;

            newProjectileInfo.sedateCharacters = weaponSettings.sedateCharacters;
            newProjectileInfo.sedateDelay = weaponSettings.sedateDelay;
            newProjectileInfo.useWeakSpotToReduceDelay = weaponSettings.useWeakSpotToReduceDelay;
            newProjectileInfo.sedateDuration = weaponSettings.sedateDuration;
            newProjectileInfo.sedateUntilReceiveDamage = weaponSettings.sedateUntilReceiveDamage;

            newProjectileInfo.pushCharacter = weaponSettings.pushCharacter;
            newProjectileInfo.pushCharacterForce = weaponSettings.pushCharacterForce;
            newProjectileInfo.pushCharacterRagdollForce = weaponSettings.pushCharacterRagdollForce;

            newProjectileInfo.setProjectileMeshRotationToFireRotation = weaponSettings.setProjectileMeshRotationToFireRotation;

            newProjectileInfo.useRemoteEventOnObjectsFound = useRemoteEventOnObjectsFound;
            newProjectileInfo.remoteEventNameList = remoteEventNameList;

            newProjectileInfo.useRemoteEventOnObjectsFoundOnExplosion = useRemoteEventOnObjectsFoundOnExplosion;
            newProjectileInfo.remoteEventNameOnExplosion = remoteEventNameOnExplosion;

            newProjectileInfo.ignoreShield = weaponSettings.ignoreShield;

            newProjectileInfo.canActivateReactionSystemTemporally = weaponSettings.canActivateReactionSystemTemporally;
            newProjectileInfo.damageReactionID = weaponSettings.damageReactionID;

            newProjectileInfo.damageTypeID = weaponSettings.damageTypeID;

            newProjectileInfo.damageCanBeBlocked = weaponSettings.damageCanBeBlocked;

            newProjectileInfo.projectilesPoolEnabled = projectilesPoolEnabled;

            newProjectileInfo.maxAmountOfPoolElementsOnWeapon = maxAmountOfPoolElementsOnWeapon;

            newProjectileInfo.allowDamageForProjectileOwner = weaponSettings.allowDamageForProjectileOwner;

            newProjectileInfo.projectileCanBeDeflected = weaponSettings.projectileCanBeDeflected;

            projectileInfoAssigned = true;
        }
    }

    public void updateProjectileInfoValues ()
    {
        projectileInfoAssigned = false;

        setProjectileInfo ();
    }

    public void setProjectileInfoAssignedValue (bool state)
    {
        projectileInfoAssigned = state;
    }

    public void setTargetToDamageLayer (LayerMask newLayer)
    {
        targetToDamageLayer = newLayer;

        if (projectileInfoAssigned) {
            newProjectileInfo.targetToDamageLayer = targetToDamageLayer;
        }
    }

    public GameObject setSeekerProjectileInfo (Vector3 shootPosition)
    {
        return applyDamage.setSeekerProjectileInfo (shootPosition, weaponSettings.tagToLocate, usingScreenSpaceCamera,
            weaponSettings.targetOnScreenForSeeker, mainCamera, targetToDamageLayer, transform.position, false, null);
    }

    public Vector3 setProjectileSpread ()
    {
        float spreadAmount = weaponSettings.thirdPersonSpreadAmountAiming;

        if (spreadAmount > 0) {
            Vector3 randomSpread = Vector3.zero;
            randomSpread.x = Random.Range (-spreadAmount, spreadAmount);
            randomSpread.y = Random.Range (-spreadAmount, spreadAmount);
            randomSpread.z = Random.Range (-spreadAmount, spreadAmount);
            return randomSpread;
        }

        return Vector3.zero;
    }

    void createShells ()
    {
        shellCreated = true;

        if (weaponSettings.shell != null) {
            for (int j = 0; j < weaponSettings.shellPosition.Count; j++) {
                //if the current weapon drops shells, create them

                if (projectilesPoolEnabled) {
                    newShellClone = GKC_PoolingSystem.Spawn (weaponSettings.shell, weaponSettings.shellPosition [j].position, weaponSettings.shellPosition [j].rotation, maxAmountOfPoolElementsOnWeapon);
                } else {
                    newShellClone = (GameObject)Instantiate (weaponSettings.shell, weaponSettings.shellPosition [j].position, weaponSettings.shellPosition [j].rotation);
                }

                newWeaponShellSystem = newShellClone.GetComponent<weaponShellSystem> ();

                if (weaponSettings.shellDropAudioElements.Count > 0) {
                    newClipToShell = weaponSettings.shellDropAudioElements [Random.Range (0, weaponSettings.shellDropAudioElements.Count - 1)];
                }

                newWeaponShellSystem.setShellValues (weaponSettings.shellPosition [j].right * (weaponSettings.shellEjectionForce * GKC_Utils.getCurrentScaleTime ()), playerCollider, newClipToShell);

                if (weaponSettings.removeDroppedShellsAfterTime) {
                    shells.Add (newShellClone);

                    if (shells.Count > weaponSettings.maxAmountOfShellsBeforeRemoveThem) {
                        currentShellToRemove = shells [0];

                        shells.RemoveAt (0);

                        if (projectilesPoolEnabled) {
                            GKC_PoolingSystem.Despawn (currentShellToRemove);
                        } else {
                            Destroy (currentShellToRemove);
                        }
                    }

                    shellsActive = true;

                    shellsOnSceneToRemove = true;
                }
            }
        }
    }

    public void checkDroppedShellsRemoval ()
    {
        //if the amount of shells from the projectiles is higher than 0, check the time to remove then
        if (shellsOnSceneToRemove && weaponSettings.removeDroppedShellsAfterTime) {
            if (shellsActive) {
                destroyShellsTimer += Time.deltaTime;

                if (destroyShellsTimer > 3) {
                    for (int i = 0; i < shells.Count; i++) {
                        if (projectilesPoolEnabled) {
                            GKC_PoolingSystem.Despawn (shells [i]);
                        } else {
                            Destroy (shells [i]);
                        }
                    }

                    shells.Clear ();

                    destroyShellsTimer = 0;

                    shellsOnSceneToRemove = false;

                    shellsActive = false;
                }
            }
        }
    }

    //play the fire sound or the empty clip sound
    void playWeaponSoundEffect (bool hasAmmo)
    {
        if (hasAmmo) {
            if (weaponSettings.shootAudioElement != null) {
                if (weaponsEffectsSource != null) {
                    weaponSettings.shootAudioElement.audioSource = weaponsEffectsSource;

                    weaponsEffectsSource.pitch = weaponSpeed;
                }

                AudioPlayer.Play (weaponSettings.shootAudioElement, gameObject);
            }
        } else {
            if (Time.time > lastShoot + weaponSettings.fireRate) {
                if (weaponsEffectsSource != null) {
                    outOfAmmoAudioElement.audioSource = weaponsEffectsSource;
                    weaponsEffectsSource.pitch = weaponSpeed;

                    GKC_Utils.checkAudioSourcePitch (weaponsEffectsSource);
                }

                AudioPlayer.PlayOneShot (outOfAmmoAudioElement, gameObject);
                lastShoot = Time.time;
            }
        }

        //		else {
        //			print ("WARNING: no audio source attached on " + gameObject.name + " weapon");
        //		}
    }

    public void playSound (AudioElement clipSound)
    {
        if (weaponsEffectsSource != null) {
            clipSound.audioSource = weaponsEffectsSource;
            GKC_Utils.checkAudioSourcePitch (weaponsEffectsSource);
        }

        AudioPlayer.PlayOneShot (clipSound, gameObject);
    }

    //create the muzzle flash particles if the weapon has it
    void createMuzzleFlash ()
    {
        if (weaponSettings.shootParticles != null) {
            for (int j = 0; j < weaponSettings.projectilePosition.Count; j++) {
                currentProjectilePosition = weaponSettings.projectilePosition [j];

                if (projectilesPoolEnabled) {
                    newMuzzleParticlesClone = GKC_PoolingSystem.Spawn (weaponSettings.shootParticles, currentProjectilePosition.position, currentProjectilePosition.rotation, maxAmountOfPoolElementsOnWeapon);
                } else {
                    newMuzzleParticlesClone = (GameObject)Instantiate (weaponSettings.shootParticles, currentProjectilePosition.position, currentProjectilePosition.rotation);
                }

                if (weaponSettings.setShootParticlesLayerOnFirstPerson) {
                    if (mainPlayerWeaponsManagerLocated) {
                        if (mainPlayerWeaponsManager.isFirstPersonActive ()) {
                            mainPlayerWeaponsManager.setWeaponPartLayer (newMuzzleParticlesClone);
                        }
                    }
                }

                if (projectilesPoolEnabled) {

                } else {
                    Destroy (newMuzzleParticlesClone, 1);
                }

                newMuzzleParticlesClone.transform.SetParent (currentProjectilePosition);
            }
        }
    }

    //	//decrease the amount of ammo in the clip
    public void useAmmo ()
    {
        weaponSettings.clipSize--;
    }

    public void useAmmo (int amount)
    {
        if (amount > weaponSettings.clipSize) {
            amount = weaponSettings.clipSize;
        }

        weaponSettings.clipSize -= amount;
    }

    /// <summary>
    /// Checks and handles the amount of remaining ammo.
    /// </summary>
    void checkRemainingAmmo ()
    {
        // If the weapon has not infinite ammo
        if (!weaponSettings.infiniteAmmo) {
            //the clip is empty
            if (weaponSettings.clipSize == 0) {
                //if the remaining ammo is lower that the ammo per clip, set the final projectiles in the clip 
                if (weaponSettings.remainAmmo < weaponSettings.ammoPerClip) {
                    weaponSettings.clipSize = weaponSettings.remainAmmo;
                }
                //else, refill it
                else {
                    weaponSettings.clipSize = weaponSettings.ammoPerClip;
                }

                //if the remaining ammo is higher than 0, remove the current projectiles added in the clip
                if (weaponSettings.remainAmmo > 0) {
                    weaponSettings.remainAmmo -= weaponSettings.clipSize;
                }
            }
            //the clip has some bullets in it yet
            else {
                int usedAmmo = 0;

                if (weaponSettings.removePreviousAmmoOnClip) {
                    weaponSettings.clipSize = 0;

                    if (weaponSettings.remainAmmo < (weaponSettings.ammoPerClip)) {
                        usedAmmo = weaponSettings.remainAmmo;
                    } else {
                        usedAmmo = weaponSettings.ammoPerClip;
                    }
                } else {
                    if (weaponSettings.remainAmmo < (weaponSettings.ammoPerClip - weaponSettings.clipSize)) {
                        usedAmmo = weaponSettings.remainAmmo;
                    } else {
                        usedAmmo = weaponSettings.ammoPerClip - weaponSettings.clipSize;
                    }
                }

                weaponSettings.remainAmmo -= usedAmmo;
                weaponSettings.clipSize += usedAmmo;
            }
        } else {
            // else, the weapon has infinite ammo, so refill it
            weaponSettings.clipSize = weaponSettings.ammoPerClip;
        }

        weaponSettings.auxRemainAmmo = weaponSettings.remainAmmo;
    }

    public void reloadWeapon (float waitTimeAmount)
    {
        if (reloadCoroutine != null) {
            StopCoroutine (reloadCoroutine);
        }

        reloadCoroutine = StartCoroutine (waitToReload (waitTimeAmount));
    }

    /// <summary>
    /// Adds a delay when reloading weapons for the given amount of seconds.
    /// </summary>
    /// <param name="waitTimeAmount">Number of seconds to wait before reloading.</param>
    IEnumerator waitToReload (float waitTimeAmount)
    {
        //print ("reload");
        // If the remaining ammo is higher than 0 or infinite
        if (weaponSettings.remainAmmo > 0 || weaponSettings.infiniteAmmo) {
            // Reload
            reloading = true;

            // Play the reload sound
            if (weaponSettings.reloadAudioElement != null) {
                playSound (weaponSettings.reloadAudioElement);
            }

            if (weaponSettings.dropClipWhenReload) {
                GameObject newClipToDrop = (GameObject)Instantiate (weaponSettings.clipModel, weaponSettings.positionToDropClip.position, weaponSettings.positionToDropClip.rotation);
                Collider newClipCollider = newClipToDrop.GetComponent<Collider> ();

                if (newClipCollider != null && playerCollider != null) {
                    Physics.IgnoreCollision (playerCollider, newClipCollider);
                }
            }

            // Wait an amount of time
            WaitForSeconds delay = new WaitForSeconds (waitTimeAmount);

            yield return delay;

            // Check the ammo values
            checkRemainingAmmo ();

            // Stop reload
            reloading = false;
        } else {
            // else, the weapon is out of ammo, play the empty weapon sound
            playWeaponSoundEffect (false);
        }

        yield return null;
    }

    public void manualReload ()
    {
        if (!reloading) {
            if (weaponSettings.clipSize < weaponSettings.ammoPerClip) {
                reloadWeapon (weaponSettings.reloadDelayThirdPerson);
            }
        }
    }

    public bool canIncreaseRemainAmmo ()
    {
        if (weaponSettings.auxRemainAmmo < weaponSettings.ammoLimit) {
            return true;
        } else {
            return false;
        }
    }

    public bool hasMaximumAmmoAmount ()
    {
        if (weaponSettings.useAmmoLimit) {
            if (weaponSettings.remainAmmo >= weaponSettings.ammoLimit) {
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }

    public bool hasAmmoLimit ()
    {
        return weaponSettings.useAmmoLimit;
    }

    public int ammoAmountToMaximumLimit ()
    {
        return weaponSettings.ammoLimit - weaponSettings.auxRemainAmmo;
    }

    //the vehicle has used an ammo pickup, so increase the correct weapon by name
    public void getAmmo (int amount)
    {
        bool empty = false;

        if (weaponSettings.remainAmmo == 0 && weaponSettings.clipSize == 0) {
            empty = true;
        }

        weaponSettings.remainAmmo += amount;

        if (empty) {
            if (weaponSettings.autoReloadWhenClipEmpty) {
                manualReload ();
            }
        }

        weaponSettings.auxRemainAmmo = weaponSettings.remainAmmo;
    }

    public void addAuxRemainAmmo (int amount)
    {
        weaponSettings.auxRemainAmmo += amount;
    }

    public bool hasAnyAmmo ()
    {
        if (weaponSettings.remainAmmo > 0 || weaponSettings.clipSize > 0 || weaponSettings.infiniteAmmo) {
            return true;
        }

        return false;
    }

    public void getAndUpdateAmmo (int amount)
    {
        getAmmo (amount);
    }

    public bool remainAmmoInClip ()
    {
        return weaponSettings.clipSize > 0;
    }

    public void checkSendProjectileOnEventFire ()
    {
        if (sendProjectileEventOnFire) {
            projectileEventOnFire.Invoke (currentProjectile);
        }
    }

    public void launchCurrentProjectile (GameObject newProjectile, Rigidbody projectileRigidbody, Vector3 cameraDirection)
    {
        //launch the projectile according to the velocity calculated according to the hit point of a raycast from the camera position
        projectileRigidbody.isKinematic = false;

        if (weaponSettings.useParableSpeed) {
            Vector3 newVel = getParableSpeed (newProjectile.transform.position, aimedZone, cameraDirection);

            if (newVel == -Vector3.one) {
                newVel = newProjectile.transform.forward * 100;
            }

            projectileRigidbody.AddForce (newVel, ForceMode.VelocityChange);
        } else {
            projectileRigidbody.AddForce (weaponSettings.parableDirectionTransform.forward * weaponSettings.projectileSpeed, ForceMode.Impulse);
        }
    }

    //calculate the speed applied to the launched projectile to make a parable according to a hit point
    Vector3 getParableSpeed (Vector3 origin, Vector3 target, Vector3 cameraDirection)
    {
        //if a hit point is not found, return
        if (!objectiveFound) {
            if (weaponSettings.useMaxDistanceWhenNoSurfaceFound) {
                target = origin + cameraDirection * weaponSettings.maxDistanceWhenNoSurfaceFound;
            } else {
                return -Vector3.one;
            }
        }

        // Get the distance between positions
        Vector3 toTarget = target - origin;
        Vector3 toTargetXZ = toTarget;

        // Remove the Y axis value
        toTargetXZ -= playerCameraGameObject.transform.InverseTransformDirection (toTargetXZ).y * playerCameraGameObject.transform.up;
        float y = playerCameraGameObject.transform.InverseTransformDirection (toTarget).y;
        float xz = toTargetXZ.magnitude;

        // Get the velocity according to distance and gravity
        float t = GKC_Utils.distance (origin, target) / 20;
        float v0y = y / t + 0.5f * Physics.gravity.magnitude * t;
        float v0xz = xz / t;

        // Create result vector for calculated starting speeds
        Vector3 result = toTargetXZ.normalized;

        // Get direction of xz but with magnitude 1
        result *= v0xz;

        // Set magnitude of xz to v0xz (starting speed in xz plane), setting the local Y value
        result -= playerCameraGameObject.transform.InverseTransformDirection (result).y * playerCameraGameObject.transform.up;
        result += playerCameraGameObject.transform.up * v0y;

        return result;
    }

    public void checkParableTrayectory (bool usingThirdPerson, bool usingFirstPerson)
    {
        //enable or disable the parable linerenderer
        if (((usingThirdPerson && weaponSettings.activateLaunchParableThirdPerson) ||
            (usingFirstPerson && weaponSettings.activateLaunchParableFirstPerson)) &&
            weaponSettings.launchProjectile) {
        }
    }

    public void getImpactListInfo ()
    {
        if (impactDecalManager == null) {
            GKC_Utils.instantiateMainManagerOnSceneWithType (mainDecalManagerName, typeof (decalManager));

            impactDecalManager = FindObjectOfType<decalManager> ();
        }

        if (impactDecalManager != null) {

            impactDecalList = new string [impactDecalManager.impactListInfo.Count + 1];

            for (int i = 0; i < impactDecalManager.impactListInfo.Count; i++) {
                string name = impactDecalManager.impactListInfo [i].name;
                impactDecalList [i] = name;
            }
        }
    }

    public void setReducedVelocity (float multiplierValue)
    {
        weaponSpeed *= multiplierValue;
    }

    public void setNormalVelocity ()
    {
        weaponSpeed = originalWeaponSpeed;
    }

    public string getWeaponSystemName ()
    {
        return weaponSettings.Name;
    }

    public int getWeaponClipSize ()
    {
        return weaponSettings.clipSize;
    }

    public string getCurrentAmmoText ()
    {
        if (!weaponSettings.infiniteAmmo) {
            return weaponSettings.clipSize + "/" + weaponSettings.remainAmmo;
        } else {
            return weaponSettings.clipSize + "/" + "Inf";
        }
    }

    public void enableMuzzleFlashLight ()
    {
        if (!weaponSettings.useMuzzleFlash) {
            return;
        }

        if (muzzleFlashCoroutine != null) {
            StopCoroutine (muzzleFlashCoroutine);
        }

        muzzleFlashCoroutine = StartCoroutine (enableMuzzleFlashCoroutine ());
    }

    IEnumerator enableMuzzleFlashCoroutine ()
    {
        weaponSettings.muzzleFlahsLight.gameObject.SetActive (true);

        WaitForSeconds delay = new WaitForSeconds (weaponSettings.muzzleFlahsDuration);

        yield return delay;

        weaponSettings.muzzleFlahsLight.gameObject.SetActive (false);

        yield return null;
    }

    public void checkWeaponShootNoise ()
    {
        if (weaponSettings.useNoise) {
            if (weaponSettings.useNoiseDetection) {
                applyDamage.sendNoiseSignal (weaponSettings.noiseRadius, playerControllerGameObject.transform.position,
                    weaponSettings.noiseDetectionLayer, weaponSettings.noiseDecibels, weaponSettings.forceNoiseDetection,
                    weaponSettings.showNoiseDetectionGizmo, weaponSettings.noiseID);
            }

            if (weaponSettings.useNoiseMesh) {
                if (!noiseMeshManagerFound) {
                    noiseMeshManagerFound = noiseMeshManager != null;

                    if (!noiseMeshManagerFound) {
                        noiseMeshManager = noiseMeshSystem.Instance;

                        noiseMeshManagerFound = noiseMeshManager != null;
                    }

                    if (!noiseMeshManagerFound) {
                        GKC_Utils.instantiateMainManagerOnSceneWithTypeOnApplicationPlaying (noiseMeshSystem.getMainManagerName (), typeof (noiseMeshSystem), true);

                        noiseMeshManager = noiseMeshSystem.Instance;

                        noiseMeshManagerFound = noiseMeshManager != null;
                    }

                    if (!noiseMeshManagerFound) {

                        noiseMeshManager = FindObjectOfType<noiseMeshSystem> ();

                        noiseMeshManagerFound = noiseMeshManager != null;
                    }
                }

                if (noiseMeshManagerFound) {
                    noiseMeshManager.addNoiseMesh (weaponSettings.noiseRadius, playerControllerGameObject.transform.position + Vector3.up, weaponSettings.noiseExpandSpeed);
                }
            }
        }
    }

    public projectileSystem getCurrentProjectileSystem ()
    {
        return currentProjectileSystem;
    }

    public List<projectileSystem> getLastProjectilesSystemListFired ()
    {
        return lastProjectilesSystemListFired;
    }


    public void setCustomprojectilePosition (List<Transform> customProjectilePosition)
    {
        weaponSettings.projectilePosition = customProjectilePosition;
    }

    public void setCustomTagsToIgnore (List<string> newTagList)
    {
        if (newTagList != null) {
            useCustomIgnoreTags = true;

            customTagsToIgnoreList = newTagList;
        } else {
            useCustomIgnoreTags = false;

            customTagsToIgnoreList.Clear ();
        }
    }

    Transform customMainCameraTransform;

    bool useCustomMainCameraTransformActive;

    public void setCustommainCameraTransform (Transform newTransform)
    {
        customMainCameraTransform = newTransform;

        useCustomMainCameraTransformActive = customMainCameraTransform != null;
    }
}