add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/AI/Custom Orders/characterToReceiveOrders.cs

@@ -0,0 +1,165 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class characterToReceiveOrders : MonoBehaviour
+{
+    [Header ("Main Settings")]
+    [Space]
+
+    public bool receiveOrdersEnabled = true;
+
+    [Space]
+    [Header ("Order Info Settings")]
+    [Space]
+
+    public List<characterOrderInfo> characterOrderInfoList = new List<characterOrderInfo> ();
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool showDebugPrint;
+
+    public bool orderInProcess;
+
+    public Transform currentTarget;
+
+
+
+    characterOrderInfo newCharacterOrderInfo;
+
+    Coroutine orderActionCoroutine;
+
+
+    public bool containsOrderName (string orderName)
+    {
+        int orderIndex = characterOrderInfoList.FindIndex (a => a.Name.Equals (orderName));
+
+        if (orderIndex > -1) {
+            if (!characterOrderInfoList [orderIndex].orderEnabled) {
+                return false;
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public void activateOrder (string orderName)
+    {
+        if (showDebugPrint) {
+            print ("order to Check " + orderName);
+        }
+
+        int orderIndex = characterOrderInfoList.FindIndex (a => a.Name.Equals (orderName));
+
+        if (orderIndex > -1) {
+            newCharacterOrderInfo = characterOrderInfoList [orderIndex];
+
+            if (!newCharacterOrderInfo.orderEnabled) {
+                return;
+            }
+
+            if (showDebugPrint) {
+                print ("order activated " + orderName);
+            }
+
+            if (newCharacterOrderInfo.useEventOnOrderReceived) {
+                newCharacterOrderInfo.eventOnOrderReceived.Invoke ();
+            }
+
+            if (newCharacterOrderInfo.useOrderActionDuration) {
+                stopOrderActionCoroutine ();
+
+                orderActionCoroutine = StartCoroutine (updateOrderActionCoroutine ());
+            }
+
+            if (newCharacterOrderInfo.useSimpleAIAction) {
+                newCharacterOrderInfo.mainSimpleAIAction.startAIAction ();
+            }
+        }
+    }
+
+    void stopOrderActionCoroutine ()
+    {
+        if (orderActionCoroutine != null) {
+            StopCoroutine (orderActionCoroutine);
+        }
+
+        orderInProcess = false;
+    }
+
+    IEnumerator updateOrderActionCoroutine ()
+    {
+        orderInProcess = true;
+
+        WaitForSeconds delay = new WaitForSeconds (newCharacterOrderInfo.orderActionDuration);
+
+        yield return delay;
+
+        newCharacterOrderInfo.eventOnOrderActionComplete.Invoke ();
+
+        orderInProcess = false;
+    }
+
+    public void setCustomTarget (Transform newTarget)
+    {
+        currentTarget = newTarget;
+
+        if (currentTarget != null) {
+            if (newCharacterOrderInfo != null) {
+                if (newCharacterOrderInfo.useEventToSendTarget) {
+                    newCharacterOrderInfo.eventToSendTarget.Invoke (currentTarget);
+                }
+
+                if (newCharacterOrderInfo.sendTargetOnSimpleAIAction) {
+                    if (newCharacterOrderInfo.useSimpleAIAction) {
+                        newCharacterOrderInfo.mainSimpleAIAction.setCustomTarget (newTarget);
+                    }
+                }
+            }
+        }
+    }
+
+    public bool isOrderInProcess ()
+    {
+        return orderInProcess;
+    }
+
+    [System.Serializable]
+    public class characterOrderInfo
+    {
+        public string Name;
+
+        public bool orderEnabled = true;
+
+        [Space]
+
+        public bool useEventOnOrderReceived;
+
+        public UnityEvent eventOnOrderReceived;
+
+        [Space]
+
+        public bool useOrderActionDuration;
+        public float orderActionDuration;
+
+        public UnityEvent eventOnOrderActionComplete;
+
+        [Space]
+
+        public bool useEventToSendTarget;
+        public eventParameters.eventToCallWithTransform eventToSendTarget;
+
+        [Space]
+
+        public bool useSimpleAIAction;
+
+        public simpleAIAction mainSimpleAIAction;
+
+        public bool sendTargetOnSimpleAIAction;
+    }
+}

Assets/Game Kit Controller/Scripts/AI/Custom Orders/characterToReceiveOrders.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 92b0043822e534e42a9e44846dc7cdb6
+timeCreated: 1670890122
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure Creator 3D + 2.5D
+  packageVersion: 3.77g
+  assetPath: Assets/Game Kit Controller/Scripts/AI/Custom Orders/characterToReceiveOrders.cs
+  uploadId: 814740

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehavior.cs

@@ -0,0 +1,60 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class customOrderBehavior : MonoBehaviour
+{
+	[Header ("Main Settings")]
+	[Space]
+
+	public bool orderEnabled = true;
+
+	[Space]
+	[Header ("Debug")]
+	[Space]
+
+	public bool showDebugPrint;
+    public Transform currentTarget;
+
+	[Space]
+	[Header ("Event Settings")]
+	[Space]
+
+	public bool useEventToSendTarget;
+	public eventParameters.eventToCallWithTransform eventToSendTarget;
+
+    public virtual void activateOrder (Transform character)
+	{
+	
+	}
+
+	public virtual void activateOrder (Transform character, Transform orderOwner)
+	{
+
+	}
+
+	public virtual Transform getCustomTarget (Transform character, Transform orderOwner)
+	{
+
+
+		return null;
+	}
+
+    public virtual void setCustomTarget (Transform newTarget)
+    {
+		currentTarget = newTarget;
+
+		if (useEventToSendTarget) {
+			if (currentTarget != null) {
+				eventToSendTarget.Invoke (currentTarget);
+			}
+		}
+    }
+
+    public virtual bool checkConditionToShowOrderButton (Transform character)
+	{
+
+		return false;
+	}
+}

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehavior.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 4dd1f0331b876354686b6cdd67ec16d2
+timeCreated: 1670783147
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure Creator 3D + 2.5D
+  packageVersion: 3.77g
+  assetPath: Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehavior.cs
+  uploadId: 814740

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToAttack.cs

@@ -0,0 +1,409 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class customOrderBehaviorToAttack : customOrderBehavior
+{
+    [Header ("Custom Settings")]
+    [Space]
+
+    public List<string> tagToLocate = new List<string> ();
+
+    public bool checkIfTargetOnLockOnViewEnabled = true;
+
+    public bool sendPlayerAsTarget;
+
+    [Space]
+    [Header ("Target Detection Settings")]
+    [Space]
+
+    public bool getClosestTargetToCameraViewIfNoLockOnActive;
+
+    public float maxDistanceToFindTarget = 300;
+
+    public bool searchPointToLookComponents = true;
+
+    public bool lookOnlyIfTargetOnScreen;
+
+    public bool checkObstaclesToTarget;
+
+    public LayerMask layerToLook;
+
+    public LayerMask pointToLookComponentsLayer;
+
+    public bool getClosestToCameraCenter;
+
+    public bool useMaxDistanceToCameraCenter;
+
+    public float maxDistanceToCameraCenter = 200;
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool showCameraGizmo;
+
+    [Space]
+    [Header ("Components")]
+    [Space]
+
+    public Transform mainCameraTransform;
+    public Transform playerCameraTransform;
+    public playerCamera mainPlayerCamera;
+    public Camera mainCamera;
+
+    public override void activateOrder (Transform character)
+    {
+
+
+    }
+
+
+    public override Transform getCustomTarget (Transform character, Transform orderOwner)
+    {
+        if (sendPlayerAsTarget) {
+            return orderOwner;
+        }
+
+        if (canAIAttack (character)) {
+
+            if (checkIfTargetOnLockOnViewEnabled) {
+                playerComponentsManager currentPlayerComponentsManager = orderOwner.GetComponent<playerComponentsManager> ();
+
+                if (currentPlayerComponentsManager != null) {
+                    playerCamera currentPlayerCamera = currentPlayerComponentsManager.getPlayerCamera ();
+
+                    if (currentPlayerCamera != null) {
+                        if (currentPlayerCamera.isPlayerLookingAtTarget ()) {
+                            Transform currentTarget = currentPlayerCamera.getLastCharacterToLook ();
+
+                            if (currentTarget != null) {
+                                if (applyDamage.isCharacter (currentTarget.gameObject)) {
+                                    if (showDebugPrint) {
+                                        print ("target located " + currentTarget.name);
+                                    }
+
+                                    return currentTarget;
+                                } else {
+                                    if (applyDamage.getCharacterFromPlaceToShoot (currentTarget)) {
+                                        if (showDebugPrint) {
+                                            print ("target located " + currentTarget.name);
+                                        }
+
+                                        return currentTarget;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (getClosestTargetToCameraViewIfNoLockOnActive) {
+                            Transform currentTarget = getClosestEnemyToScreenView ();
+
+                            if (currentTarget != null) {
+                                if (applyDamage.isCharacter (currentTarget.gameObject)) {
+                                    if (showDebugPrint) {
+                                        print ("target located " + currentTarget.name);
+                                    }
+
+                                    return currentTarget;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return getClosestEnemy (orderOwner);
+        }
+
+        return null;
+    }
+
+    public bool canAIAttack (Transform AIFriend)
+    {
+        bool canAttack = false;
+
+        findObjectivesSystem currentFindObjectivesSystem = AIFriend.GetComponentInChildren<findObjectivesSystem> ();
+
+        if (currentFindObjectivesSystem != null) {
+            if (currentFindObjectivesSystem.attackType != findObjectivesSystem.AIAttackType.none) {
+                canAttack = true;
+            }
+        }
+
+        return canAttack;
+    }
+
+    public Transform getClosestEnemy (Transform centerPointTransform)
+    {
+        Vector3 centerPosition = centerPointTransform.position;
+
+        List<GameObject> fullEnemyList = new List<GameObject> ();
+
+        GameObject closestEnemy;
+
+        for (int i = 0; i < tagToLocate.Count; i++) {
+            GameObject [] enemiesList = GameObject.FindGameObjectsWithTag (tagToLocate [i]);
+
+            fullEnemyList.AddRange (enemiesList);
+        }
+
+        List<GameObject> closestEnemyList = new List<GameObject> ();
+
+        for (int j = 0; j < fullEnemyList.Count; j++) {
+            if (!applyDamage.checkIfDead (fullEnemyList [j])) {
+                closestEnemyList.Add (fullEnemyList [j]);
+            }
+        }
+
+        if (closestEnemyList.Count > 0) {
+            float distance = Mathf.Infinity;
+
+            int index = -1;
+
+            for (int j = 0; j < closestEnemyList.Count; j++) {
+                float currentDistance = GKC_Utils.distance (closestEnemyList [j].transform.position, centerPosition);
+
+                if (currentDistance < distance) {
+                    distance = currentDistance;
+                    index = j;
+                }
+            }
+
+            if (index != -1) {
+                closestEnemy = closestEnemyList [index];
+
+                return closestEnemy.transform;
+            }
+        }
+
+        return null;
+    }
+    public Transform getClosestEnemyToScreenView ()
+    {
+        List<Collider> targetsListCollider = new List<Collider> ();
+
+        List<GameObject> targetList = new List<GameObject> ();
+        List<GameObject> fullTargetList = new List<GameObject> ();
+
+        List<Transform> targetsListToLookTransform = new List<Transform> ();
+
+        int tagToLocateCount = tagToLocate.Count;
+
+        for (int i = 0; i < tagToLocateCount; i++) {
+            GameObject [] enemiesList = GameObject.FindGameObjectsWithTag (tagToLocate [i]);
+            targetList.AddRange (enemiesList);
+        }
+
+        int targetListCount = targetList.Count;
+
+        for (int i = 0; i < targetListCount; i++) {
+            float distance = GKC_Utils.distance (targetList [i].transform.position, playerCameraTransform.position);
+
+            if (distance < maxDistanceToFindTarget) {
+                fullTargetList.Add (targetList [i]);
+            }
+        }
+
+        List<GameObject> pointToLookComponentList = new List<GameObject> ();
+
+        if (searchPointToLookComponents) {
+            targetsListCollider.Clear ();
+
+            targetsListCollider.AddRange (Physics.OverlapSphere (playerCameraTransform.position, maxDistanceToFindTarget, pointToLookComponentsLayer));
+
+            int targetsListColliderCount = targetsListCollider.Count;
+
+            for (int i = 0; i < targetsListColliderCount; i++) {
+                if (targetsListCollider [i].isTrigger) {
+                    pointToLook currentPointToLook = targetsListCollider [i].GetComponent<pointToLook> ();
+
+                    if (currentPointToLook != null) {
+                        if (currentPointToLook.isPointToLookEnabled ()) {
+                            GameObject currenTargetToLook = currentPointToLook.getPointToLookTransform ().gameObject;
+
+                            fullTargetList.Add (currenTargetToLook);
+
+                            pointToLookComponentList.Add (currenTargetToLook);
+                        }
+                    }
+                }
+            }
+        }
+
+        bool isUsingScreenSpaceCamera = mainPlayerCamera.isUsingScreenSpaceCamera ();
+
+        float screenWidth = Screen.width;
+        float screenHeight = Screen.height;
+
+        Vector3 screenPoint;
+
+        bool targetOnScreen;
+
+        int fullTargetListCount = fullTargetList.Count;
+
+        RaycastHit hit = new RaycastHit ();
+
+        for (int i = 0; i < fullTargetListCount; i++) {
+            if (fullTargetList [i] != null) {
+                GameObject currentTarget = fullTargetList [i];
+
+                if (tagToLocate.Contains (currentTarget.tag) || pointToLookComponentList.Contains (currentTarget)) {
+                    bool objectVisible = false;
+                    bool obstacleDetected = false;
+
+                    Vector3 targetPosition = currentTarget.transform.position;
+
+                    if (lookOnlyIfTargetOnScreen) {
+                        Transform currentTargetPlaceToShoot = applyDamage.getPlaceToShoot (currentTarget);
+
+                        if (currentTargetPlaceToShoot != null) {
+                            targetPosition = currentTargetPlaceToShoot.position;
+                        }
+
+                        if (isUsingScreenSpaceCamera) {
+                            screenPoint = mainCamera.WorldToViewportPoint (targetPosition);
+                            targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < 1 && screenPoint.y > 0 && screenPoint.y < 1;
+                        } else {
+                            screenPoint = mainCamera.WorldToScreenPoint (targetPosition);
+                            targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < screenWidth && screenPoint.y > 0 && screenPoint.y < screenHeight;
+                        }
+
+                        //the target is visible in the screen
+                        if (targetOnScreen) {
+                            objectVisible = true;
+                        }
+                    } else {
+                        objectVisible = true;
+                    }
+
+                    if (objectVisible && checkObstaclesToTarget) {
+                        //for every target in front of the camera, use a raycast, if it finds an obstacle between the target and the camera, the target is removed from the list
+                        Vector3 temporaltargetPosition = targetPosition;
+
+                        Transform temporalPlaceToShoot = applyDamage.getPlaceToShoot (currentTarget);
+
+                        if (temporalPlaceToShoot != null) {
+                            temporaltargetPosition = temporalPlaceToShoot.position;
+                        }
+
+                        Vector3 direction = temporaltargetPosition - mainCameraTransform.position;
+
+                        direction = direction / direction.magnitude;
+
+                        float distance = GKC_Utils.distance (temporaltargetPosition, mainCameraTransform.position);
+
+                        if (Physics.Raycast (temporaltargetPosition, -direction, out hit, distance, layerToLook)) {
+                            obstacleDetected = true;
+
+                            if (showCameraGizmo) {
+                                Debug.DrawLine (temporaltargetPosition, hit.point, Color.white, 4);
+                            }
+
+                            if (showDebugPrint) {
+                                print ("obstacle detected " + hit.collider.name + " " + currentTarget.name);
+                            }
+                        }
+                    }
+
+                    if (objectVisible && !obstacleDetected) {
+                        targetsListToLookTransform.Add (currentTarget.transform);
+                    }
+                }
+            }
+        }
+
+        //finally, get the target closest to the player
+        float minDistance = Mathf.Infinity;
+
+        Vector3 centerScreen = mainPlayerCamera.getScreenCenter ();
+
+        int targetsListToLookTransformCount = targetsListToLookTransform.Count;
+
+        Transform placeToShoot;
+
+        bool targetFound = false;
+
+        Transform targetToLook = null;
+
+        for (int i = 0; i < targetsListToLookTransformCount; i++) {
+
+            //find closes element to center screen
+            if (getClosestToCameraCenter) {
+                Vector3 targetPosition = targetsListToLookTransform [i].position;
+
+                placeToShoot = applyDamage.getPlaceToShoot (targetsListToLookTransform [i].gameObject);
+
+                if (placeToShoot != null) {
+                    targetPosition = placeToShoot.position;
+                }
+
+                screenPoint = mainCamera.WorldToScreenPoint (targetPosition);
+
+                //				print (screenPoint + " " + centerScreen);
+
+                float currentDistance = GKC_Utils.distance (screenPoint, centerScreen);
+
+                bool canBeChecked = false;
+
+                if (useMaxDistanceToCameraCenter) {
+                    if (currentDistance < maxDistanceToCameraCenter) {
+                        canBeChecked = true;
+                    }
+                } else {
+                    canBeChecked = true;
+                }
+
+                if (canBeChecked) {
+                    if (currentDistance < minDistance) {
+                        minDistance = currentDistance;
+
+                        targetToLook = targetsListToLookTransform [i];
+
+                        targetFound = true;
+                    }
+                }
+            } else {
+                float currentDistance = GKC_Utils.distance (targetsListToLookTransform [i].position, playerCameraTransform.position);
+
+                if (currentDistance < minDistance) {
+                    minDistance = currentDistance;
+
+                    targetToLook = targetsListToLookTransform [i];
+
+                    targetFound = true;
+                }
+            }
+        }
+
+        if (targetFound) {
+            //check if the object to check is too far from screen center in case the llok at body parts on characters is active and no body part is found or is close enough to screen center
+            if (useMaxDistanceToCameraCenter && getClosestToCameraCenter) {
+                placeToShoot = applyDamage.getPlaceToShoot (targetToLook.gameObject);
+
+                if (placeToShoot == null) {
+                    placeToShoot = targetToLook;
+                }
+
+                screenPoint = mainCamera.WorldToScreenPoint (placeToShoot.position);
+
+                float currentDistance = GKC_Utils.distance (screenPoint, centerScreen);
+
+                if (currentDistance > maxDistanceToCameraCenter) {
+                    targetToLook = null;
+                    targetFound = false;
+
+                    //print ("cancel look at target");
+                }
+            }
+        }
+
+        if (showDebugPrint) {
+            if (targetFound) {
+                print ("target found " + targetToLook.name);
+            }
+        }
+
+        return targetToLook;
+    }
+}

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToAttack.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: b44a371b3f0a5e249bc325eb6e598546
+timeCreated: 1670784274
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure Creator 3D + 2.5D
+  packageVersion: 3.77g
+  assetPath: Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToAttack.cs
+  uploadId: 814740

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToBorrowWeapon.cs

@@ -0,0 +1,122 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class customOrderBehaviorToBorrowWeapon : customOrderBehavior
+{
+	[Header ("Custom Settings")]
+	[Space]
+
+	public ForceMode dropForceMode;
+	public float extraForceAmount = 5;
+
+	public bool useParableSpeed;
+
+	public bool pickWeaponDirectlyOnPlayer;
+
+	public override void activateOrder (Transform character, Transform orderOwner)
+	{
+		if (!orderEnabled) {
+			return;
+		}
+
+		if (character == null) {
+			return;
+		}
+
+		playerComponentsManager currentPlayerComponentsManager = character.GetComponent<playerComponentsManager> ();
+
+		if (currentPlayerComponentsManager != null) {
+			findObjectivesSystem currentFindObjectivesSystem = currentPlayerComponentsManager.getFindObjectivesSystem ();
+
+			if (currentFindObjectivesSystem != null) {
+
+				GameObject lastWeaponDroppedObject = null;
+
+				playerWeaponsManager currentPlayerWeaponsManager = currentPlayerComponentsManager.getPlayerWeaponsManager ();
+
+				if (currentPlayerWeaponsManager != null) {
+					if (currentPlayerWeaponsManager.isWeaponsModeActive ()) {
+//						currentPlayerWeaponsManager.dropCurrentWeaponExternally ();
+
+						if (currentPlayerWeaponsManager.isUsingWeapons ()) {
+							currentFindObjectivesSystem.dropWeapon ();
+
+							lastWeaponDroppedObject = currentPlayerWeaponsManager.getLastWeaponDroppedObject ();
+
+							if (showDebugPrint) {
+								print ("dropping fire weapon");
+							}
+						}
+					} else {
+						meleeWeaponsGrabbedManager currentMeleeWeaponsGrabbedManager = currentPlayerComponentsManager.getMeleeWeaponsGrabbedManager ();
+					
+						if (currentMeleeWeaponsGrabbedManager != null) {
+							Transform currentWeaponTransform = currentMeleeWeaponsGrabbedManager.getCurrentGrabbedObjectTransform ();
+
+							if (currentWeaponTransform != null) {
+								lastWeaponDroppedObject = currentWeaponTransform.gameObject;
+
+								currentFindObjectivesSystem.dropWeapon ();
+
+								if (showDebugPrint) {
+									print ("dropping melee weapon");
+								}
+							}
+						}
+					}
+				}
+
+
+				if (lastWeaponDroppedObject != null) {
+					if (showDebugPrint) {
+						print ("weapon dropped located");
+					}
+
+					Rigidbody weaponRigidbody = lastWeaponDroppedObject.GetComponent<Rigidbody> ();
+
+					if (weaponRigidbody != null) {
+						if (useParableSpeed) {
+							Vector3 newVel = GKC_Utils.getParableSpeed (weaponRigidbody.position, orderOwner.position, character.forward,
+								                 character, true, false, 0);
+
+							if (newVel == -Vector3.one) {
+								newVel = character.forward * 100;
+							}
+
+							weaponRigidbody.AddForce (newVel, ForceMode.VelocityChange);
+						} else {
+
+							Vector3 forceDirection = orderOwner.position - weaponRigidbody.position;
+
+							float distance = forceDirection.magnitude;
+							forceDirection = forceDirection / distance;	
+
+							weaponRigidbody.AddForce (forceDirection * extraForceAmount, dropForceMode);
+						}
+					}
+
+					if (pickWeaponDirectlyOnPlayer) {
+						playerComponentsManager orderOwnerPlayerComponentsManager = orderOwner.GetComponent<playerComponentsManager> ();
+
+						if (orderOwnerPlayerComponentsManager != null) {
+							playerController ownerPlayerController = orderOwnerPlayerComponentsManager.getPlayerController ();
+
+							if (ownerPlayerController != null) {
+								if (!ownerPlayerController.playerIsBusy ()) {
+									simpleActionButton currentSimpleActionButton = lastWeaponDroppedObject.GetComponentInChildren<simpleActionButton> ();
+
+									if (currentSimpleActionButton != null) {
+										lastWeaponDroppedObject = currentSimpleActionButton.gameObject;
+									}
+								
+									GKC_Utils.useObjectExternally (orderOwner.gameObject, lastWeaponDroppedObject);
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToBorrowWeapon.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: de069a3bcfa2df44c9fe82ff302e54a9
+timeCreated: 1671165527
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure Creator 3D + 2.5D
+  packageVersion: 3.77g
+  assetPath: Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToBorrowWeapon.cs
+  uploadId: 814740

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToFollow.cs

@@ -0,0 +1,421 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class customOrderBehaviorToFollow : customOrderBehavior
+{
+    [Header ("Custom Settings")]
+    [Space]
+
+    public List<string> tagToLocate = new List<string> ();
+
+    public bool checkIfTargetOnLockOnViewEnabled = true;
+
+    public bool sendPlayerAsTarget = true;
+
+    public bool ignoreToGetClosestEnemy;
+
+    [Space]
+    [Header ("Target Detection Settings")]
+    [Space]
+
+    public bool getClosestTargetToCameraViewIfNoLockOnActive;
+
+    public float maxDistanceToFindTarget = 300;
+
+    public bool searchPointToLookComponents = true;
+
+    public bool lookOnlyIfTargetOnScreen;
+
+    public bool checkObstaclesToTarget;
+
+    public LayerMask layerToLook;
+
+    public LayerMask pointToLookComponentsLayer;
+
+    public bool getClosestToCameraCenter;
+
+    public bool useMaxDistanceToCameraCenter;
+
+    public float maxDistanceToCameraCenter = 200;
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool showCameraGizmo;
+
+    [Space]
+    [Header ("Components")]
+    [Space]
+
+    public Transform mainCameraTransform;
+    public Transform playerCameraTransform;
+    public playerCamera mainPlayerCamera;
+    public Camera mainCamera;
+
+    public override void activateOrder (Transform character)
+	{
+
+
+	}
+
+
+	public override Transform getCustomTarget (Transform character, Transform orderOwner)
+	{
+        if (sendPlayerAsTarget) {
+            return orderOwner;
+        }
+
+        if (canAIAttack (character)) {
+
+            if (checkIfTargetOnLockOnViewEnabled) {
+                playerComponentsManager currentPlayerComponentsManager = orderOwner.GetComponent<playerComponentsManager> ();
+
+                if (currentPlayerComponentsManager != null) {
+                    playerCamera currentPlayerCamera = currentPlayerComponentsManager.getPlayerCamera ();
+
+                    if (currentPlayerCamera != null) {
+                        if (currentPlayerCamera.isPlayerLookingAtTarget ()) {
+                            Transform currentTarget = currentPlayerCamera.getLastCharacterToLook ();
+
+                            if (currentTarget != null) {
+                                if (applyDamage.isCharacter (currentTarget.gameObject)) {
+                                    if (showDebugPrint) {
+                                        print ("target located " + currentTarget.name);
+                                    }
+
+                                    return currentTarget;
+                                } else {
+                                    if (applyDamage.getCharacterFromPlaceToShoot (currentTarget)) {
+                                        if (showDebugPrint) {
+                                            print ("target located " + currentTarget.name);
+                                        }
+
+                                        return currentTarget;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (getClosestTargetToCameraViewIfNoLockOnActive) {
+                            Transform currentTarget = getClosestEnemyToScreenView ();
+
+                            if (currentTarget != null) {
+                                if (applyDamage.isCharacter (currentTarget.gameObject)) {
+                                    if (showDebugPrint) {
+                                        print ("target located " + currentTarget.name);
+                                    }
+
+                                    return currentTarget;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (ignoreToGetClosestEnemy) {
+                return orderOwner;
+            }
+
+            Transform target = getClosestEnemy (orderOwner);
+
+            if (target == null) {
+                target = orderOwner;
+            }
+
+            return target;
+        }
+
+        return null;
+    }
+
+    public bool canAIAttack (Transform AIFriend)
+    {
+        bool canAttack = false;
+
+        findObjectivesSystem currentFindObjectivesSystem = AIFriend.GetComponentInChildren<findObjectivesSystem> ();
+
+        if (currentFindObjectivesSystem != null) {
+            if (currentFindObjectivesSystem.attackType != findObjectivesSystem.AIAttackType.none) {
+                canAttack = true;
+            }
+        }
+
+        return canAttack;
+    }
+
+    public Transform getClosestEnemy (Transform centerPointTransform)
+    {
+        Vector3 centerPosition = centerPointTransform.position;
+
+        List<GameObject> fullEnemyList = new List<GameObject> ();
+
+        GameObject closestEnemy;
+
+        for (int i = 0; i < tagToLocate.Count; i++) {
+            GameObject [] enemiesList = GameObject.FindGameObjectsWithTag (tagToLocate [i]);
+
+            fullEnemyList.AddRange (enemiesList);
+        }
+
+        List<GameObject> closestEnemyList = new List<GameObject> ();
+
+        for (int j = 0; j < fullEnemyList.Count; j++) {
+            if (!applyDamage.checkIfDead (fullEnemyList [j])) {
+                closestEnemyList.Add (fullEnemyList [j]);
+            }
+        }
+
+        if (closestEnemyList.Count > 0) {
+            float distance = Mathf.Infinity;
+
+            int index = -1;
+
+            for (int j = 0; j < closestEnemyList.Count; j++) {
+                float currentDistance = GKC_Utils.distance (closestEnemyList [j].transform.position, centerPosition);
+
+                if (currentDistance < distance) {
+                    distance = currentDistance;
+                    index = j;
+                }
+            }
+
+            if (index != -1) {
+                closestEnemy = closestEnemyList [index];
+
+                return closestEnemy.transform;
+            }
+        }
+
+        return null;
+    }
+    public Transform getClosestEnemyToScreenView ()
+    {
+        List<Collider> targetsListCollider = new List<Collider> ();
+
+        List<GameObject> targetList = new List<GameObject> ();
+        List<GameObject> fullTargetList = new List<GameObject> ();
+
+        List<Transform> targetsListToLookTransform = new List<Transform> ();
+
+        int tagToLocateCount = tagToLocate.Count;
+
+        for (int i = 0; i < tagToLocateCount; i++) {
+            GameObject [] enemiesList = GameObject.FindGameObjectsWithTag (tagToLocate [i]);
+            targetList.AddRange (enemiesList);
+        }
+
+        int targetListCount = targetList.Count;
+
+        for (int i = 0; i < targetListCount; i++) {
+            float distance = GKC_Utils.distance (targetList [i].transform.position, playerCameraTransform.position);
+
+            if (distance < maxDistanceToFindTarget) {
+                fullTargetList.Add (targetList [i]);
+            }
+        }
+
+        List<GameObject> pointToLookComponentList = new List<GameObject> ();
+
+        if (searchPointToLookComponents) {
+            targetsListCollider.Clear ();
+
+            targetsListCollider.AddRange (Physics.OverlapSphere (playerCameraTransform.position, maxDistanceToFindTarget, pointToLookComponentsLayer));
+
+            int targetsListColliderCount = targetsListCollider.Count;
+
+            for (int i = 0; i < targetsListColliderCount; i++) {
+                if (targetsListCollider [i].isTrigger) {
+                    pointToLook currentPointToLook = targetsListCollider [i].GetComponent<pointToLook> ();
+
+                    if (currentPointToLook != null) {
+                        if (currentPointToLook.isPointToLookEnabled ()) {
+                            GameObject currenTargetToLook = currentPointToLook.getPointToLookTransform ().gameObject;
+
+                            fullTargetList.Add (currenTargetToLook);
+
+                            pointToLookComponentList.Add (currenTargetToLook);
+                        }
+                    }
+                }
+            }
+        }
+
+        bool isUsingScreenSpaceCamera = mainPlayerCamera.isUsingScreenSpaceCamera ();
+
+        float screenWidth = Screen.width;
+        float screenHeight = Screen.height;
+
+        Vector3 screenPoint;
+
+        bool targetOnScreen;
+
+        int fullTargetListCount = fullTargetList.Count;
+
+        RaycastHit hit = new RaycastHit ();
+
+        for (int i = 0; i < fullTargetListCount; i++) {
+            if (fullTargetList [i] != null) {
+                GameObject currentTarget = fullTargetList [i];
+
+                if (tagToLocate.Contains (currentTarget.tag) || pointToLookComponentList.Contains (currentTarget)) {
+                    bool objectVisible = false;
+                    bool obstacleDetected = false;
+
+                    Vector3 targetPosition = currentTarget.transform.position;
+
+                    if (lookOnlyIfTargetOnScreen) {
+                        Transform currentTargetPlaceToShoot = applyDamage.getPlaceToShoot (currentTarget);
+
+                        if (currentTargetPlaceToShoot != null) {
+                            targetPosition = currentTargetPlaceToShoot.position;
+                        }
+
+                        if (isUsingScreenSpaceCamera) {
+                            screenPoint = mainCamera.WorldToViewportPoint (targetPosition);
+                            targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < 1 && screenPoint.y > 0 && screenPoint.y < 1;
+                        } else {
+                            screenPoint = mainCamera.WorldToScreenPoint (targetPosition);
+                            targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < screenWidth && screenPoint.y > 0 && screenPoint.y < screenHeight;
+                        }
+
+                        //the target is visible in the screen
+                        if (targetOnScreen) {
+                            objectVisible = true;
+                        }
+                    } else {
+                        objectVisible = true;
+                    }
+
+                    if (objectVisible && checkObstaclesToTarget) {
+                        //for every target in front of the camera, use a raycast, if it finds an obstacle between the target and the camera, the target is removed from the list
+                        Vector3 temporaltargetPosition = targetPosition;
+
+                        Transform temporalPlaceToShoot = applyDamage.getPlaceToShoot (currentTarget);
+
+                        if (temporalPlaceToShoot != null) {
+                            temporaltargetPosition = temporalPlaceToShoot.position;
+                        }
+
+                        Vector3 direction = temporaltargetPosition - mainCameraTransform.position;
+
+                        direction = direction / direction.magnitude;
+
+                        float distance = GKC_Utils.distance (temporaltargetPosition, mainCameraTransform.position);
+
+                        if (Physics.Raycast (temporaltargetPosition, -direction, out hit, distance, layerToLook)) {
+                            obstacleDetected = true;
+
+                            if (showCameraGizmo) {
+                                Debug.DrawLine (temporaltargetPosition, hit.point, Color.white, 4);
+                            }
+
+                            if (showDebugPrint) {
+                                print ("obstacle detected " + hit.collider.name + " " + currentTarget.name);
+                            }
+                        }
+                    }
+
+                    if (objectVisible && !obstacleDetected) {
+                        targetsListToLookTransform.Add (currentTarget.transform);
+                    }
+                }
+            }
+        }
+
+        //finally, get the target closest to the player
+        float minDistance = Mathf.Infinity;
+
+        Vector3 centerScreen = mainPlayerCamera.getScreenCenter ();
+
+        int targetsListToLookTransformCount = targetsListToLookTransform.Count;
+
+        Transform placeToShoot;
+
+        bool targetFound = false;
+
+        Transform targetToLook = null;
+
+        for (int i = 0; i < targetsListToLookTransformCount; i++) {
+
+            //find closes element to center screen
+            if (getClosestToCameraCenter) {
+                Vector3 targetPosition = targetsListToLookTransform [i].position;
+
+                placeToShoot = applyDamage.getPlaceToShoot (targetsListToLookTransform [i].gameObject);
+
+                if (placeToShoot != null) {
+                    targetPosition = placeToShoot.position;
+                }
+
+                screenPoint = mainCamera.WorldToScreenPoint (targetPosition);
+
+                //				print (screenPoint + " " + centerScreen);
+
+                float currentDistance = GKC_Utils.distance (screenPoint, centerScreen);
+
+                bool canBeChecked = false;
+
+                if (useMaxDistanceToCameraCenter) {
+                    if (currentDistance < maxDistanceToCameraCenter) {
+                        canBeChecked = true;
+                    }
+                } else {
+                    canBeChecked = true;
+                }
+
+                if (canBeChecked) {
+                    if (currentDistance < minDistance) {
+                        minDistance = currentDistance;
+
+                        targetToLook = targetsListToLookTransform [i];
+
+                        targetFound = true;
+                    }
+                }
+            } else {
+                float currentDistance = GKC_Utils.distance (targetsListToLookTransform [i].position, playerCameraTransform.position);
+
+                if (currentDistance < minDistance) {
+                    minDistance = currentDistance;
+
+                    targetToLook = targetsListToLookTransform [i];
+
+                    targetFound = true;
+                }
+            }
+        }
+
+        if (targetFound) {
+            //check if the object to check is too far from screen center in case the look at body parts on characters is active and no body part is found or is close enough to screen center
+            if (useMaxDistanceToCameraCenter && getClosestToCameraCenter) {
+                placeToShoot = applyDamage.getPlaceToShoot (targetToLook.gameObject);
+
+                if (placeToShoot == null) {
+                    placeToShoot = targetToLook;
+                }
+
+                screenPoint = mainCamera.WorldToScreenPoint (placeToShoot.position);
+
+                float currentDistance = GKC_Utils.distance (screenPoint, centerScreen);
+
+                if (currentDistance > maxDistanceToCameraCenter) {
+                    targetToLook = null;
+                    targetFound = false;
+
+                    //print ("cancel look at target");
+                }
+            }
+        }
+
+        if (showDebugPrint) {
+            if (targetFound) {
+                print ("target found " + targetToLook.name);
+            }
+        }
+
+        return targetToLook;
+    }
+}

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToFollow.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: f8bc796590ead5343ae61b786283d45d
+timeCreated: 1670784966
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure Creator 3D + 2.5D
+  packageVersion: 3.77g
+  assetPath: Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToFollow.cs
+  uploadId: 814740

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToHide.cs

@@ -0,0 +1,49 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class customOrderBehaviorToHide : customOrderBehavior
+{
+	AIHidePositionsManager mainAIHidePositionsManager;
+
+	public override void activateOrder (Transform character)
+	{
+
+
+	}
+
+
+	public override Transform getCustomTarget (Transform character, Transform orderOwner)
+	{
+		return getClosestHidePosition (character);
+	}
+
+	public Transform getClosestHidePosition (Transform AIFriend)
+	{
+		if (mainAIHidePositionsManager == null) {
+			mainAIHidePositionsManager = FindObjectOfType<AIHidePositionsManager> ();
+		}
+
+		if (mainAIHidePositionsManager != null) {
+			if (mainAIHidePositionsManager.hidePositionList.Count > 0) {
+				float distance = Mathf.Infinity;
+
+				int index = -1;
+
+				for (int j = 0; j < mainAIHidePositionsManager.hidePositionList.Count; j++) {
+					float currentDistance = GKC_Utils.distance (AIFriend.position, mainAIHidePositionsManager.hidePositionList [j].position);
+
+					if (currentDistance < distance) {
+						distance = currentDistance;
+
+						index = j;
+					}
+				}
+
+				return mainAIHidePositionsManager.hidePositionList [index];
+			}
+		}
+
+		return null;
+	}
+}

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToHide.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 406fae6ed14cd4a45b2b364bb6f8b117
+timeCreated: 1670785201
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure Creator 3D + 2.5D
+  packageVersion: 3.77g
+  assetPath: Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToHide.cs
+  uploadId: 814740

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToShapeShiftCharacter.cs

@@ -0,0 +1,46 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class customOrderBehaviorToShapeShiftCharacter : customOrderBehavior
+{
+	[Header ("Main Settings")]
+	[Space]
+
+	public bool changeEnabled = true;
+
+	[Space]
+	[Header ("Generic Character Settings")]
+	[Space]
+
+	public bool setRegularCharacter;
+
+	public string customCharacterNameToConfigure;
+
+	public override void activateOrder (Transform character)
+	{
+		if (!changeEnabled) {
+			return;
+		}
+
+		if (character == null) {
+			return;
+		}
+
+		playerComponentsManager currentPlayerComponentsManager = character.GetComponent<playerComponentsManager> ();
+
+		if (currentPlayerComponentsManager != null) {
+			customCharacterControllerManager currentCustomCharacterControllerManager = currentPlayerComponentsManager.getCustomCharacterControllerManager ();
+
+			if (currentCustomCharacterControllerManager != null) {
+				if (setRegularCharacter) {
+					if (currentCustomCharacterControllerManager.isCustomCharacterControllerActive ()) {
+						currentCustomCharacterControllerManager.disableCustomCharacterControllerState ();
+					}
+				} else {
+					currentCustomCharacterControllerManager.setCustomCharacterControllerState (customCharacterNameToConfigure);
+				}
+			}
+		}
+	}
+}

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToShapeShiftCharacter.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 1d805e13fb596bb47877b174f1f8f55b
+timeCreated: 1671037082
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure Creator 3D + 2.5D
+  packageVersion: 3.77g
+  assetPath: Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToShapeShiftCharacter.cs
+  uploadId: 814740

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToSwitchCharacter.cs

@@ -0,0 +1,34 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class customOrderBehaviorToSwitchCharacter : customOrderBehavior
+{
+	public playerCharactersManager mainPlayerCharactersManager;
+
+	public override void activateOrder (Transform character)
+	{
+
+
+	}
+
+
+	public override Transform getCustomTarget (Transform character, Transform orderOwner)
+	{
+		return character;
+	}
+
+
+	public override bool checkConditionToShowOrderButton (Transform character)
+	{
+		if (character == null) {
+			return false;
+		}
+
+		if (mainPlayerCharactersManager.isCharacterInList (character.gameObject)) {
+			return true;
+		}
+
+		return false;
+	}
+}

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToSwitchCharacter.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: b955bdf66c7f7b74591933612a5a82c8
+timeCreated: 1670785395
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure Creator 3D + 2.5D
+  packageVersion: 3.77g
+  assetPath: Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToSwitchCharacter.cs
+  uploadId: 814740

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToUseAbility.cs

@@ -0,0 +1,408 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class customOrderBehaviorToUseAbility : customOrderBehavior
+{
+    [Header ("Custom Settings")]
+    [Space]
+
+    public List<string> tagToLocate = new List<string> ();
+
+    public bool checkIfTargetOnLockOnViewEnabled = true;
+
+    public bool sendPlayerAsTarget;
+
+    [Space]
+    [Header ("Target Detection Settings")]
+    [Space]
+
+    public bool getClosestTargetToCameraViewIfNoLockOnActive;
+
+    public float maxDistanceToFindTarget = 300;
+
+    public bool searchPointToLookComponents = true;
+
+    public bool lookOnlyIfTargetOnScreen;
+
+    public bool checkObstaclesToTarget;
+
+    public LayerMask layerToLook;
+
+    public LayerMask pointToLookComponentsLayer;
+
+    public bool getClosestToCameraCenter;
+
+    public bool useMaxDistanceToCameraCenter;
+
+    public float maxDistanceToCameraCenter = 200;
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool showCameraGizmo;
+
+    [Space]
+    [Header ("Components")]
+    [Space]
+
+    public Transform mainCameraTransform;
+    public Transform playerCameraTransform;
+    public playerCamera mainPlayerCamera;
+    public Camera mainCamera;
+
+
+    public override void activateOrder (Transform character)
+    {
+
+    }
+
+    public override Transform getCustomTarget (Transform character, Transform orderOwner)
+    {
+        if (sendPlayerAsTarget) {
+            return orderOwner;
+        }
+
+        if (canAIAttack (character)) {
+
+            if (checkIfTargetOnLockOnViewEnabled) {
+                playerComponentsManager currentPlayerComponentsManager = orderOwner.GetComponent<playerComponentsManager> ();
+
+                if (currentPlayerComponentsManager != null) {
+                    playerCamera currentPlayerCamera = currentPlayerComponentsManager.getPlayerCamera ();
+
+                    if (currentPlayerCamera != null) {
+                        if (currentPlayerCamera.isPlayerLookingAtTarget ()) {
+                            Transform currentTarget = currentPlayerCamera.getLastCharacterToLook ();
+
+                            if (currentTarget != null) {
+                                if (applyDamage.isCharacter (currentTarget.gameObject)) {
+                                    if (showDebugPrint) {
+                                        print ("target located " + currentTarget.name);
+                                    }
+
+                                    return currentTarget;
+                                } else {
+                                    if (applyDamage.getCharacterFromPlaceToShoot (currentTarget)) {
+                                        if (showDebugPrint) {
+                                            print ("target located " + currentTarget.name);
+                                        }
+
+                                        return currentTarget;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (getClosestTargetToCameraViewIfNoLockOnActive) {
+                            Transform currentTarget = getClosestEnemyToScreenView ();
+
+                            if (currentTarget != null) {
+                                if (applyDamage.isCharacter (currentTarget.gameObject)) {
+                                    if (showDebugPrint) {
+                                        print ("target located " + currentTarget.name);
+                                    }
+
+                                    return currentTarget;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return getClosestEnemy (orderOwner);
+        }
+
+        return null;
+    }
+
+    public bool canAIAttack (Transform AIFriend)
+    {
+        bool canAttack = false;
+
+        findObjectivesSystem currentFindObjectivesSystem = AIFriend.GetComponentInChildren<findObjectivesSystem> ();
+
+        if (currentFindObjectivesSystem != null) {
+            if (currentFindObjectivesSystem.attackType != findObjectivesSystem.AIAttackType.none) {
+                canAttack = true;
+            }
+        }
+
+        return canAttack;
+    }
+
+    public Transform getClosestEnemy (Transform centerPointTransform)
+    {
+        Vector3 centerPosition = centerPointTransform.position;
+
+        List<GameObject> fullEnemyList = new List<GameObject> ();
+
+        GameObject closestEnemy;
+
+        for (int i = 0; i < tagToLocate.Count; i++) {
+            GameObject [] enemiesList = GameObject.FindGameObjectsWithTag (tagToLocate [i]);
+
+            fullEnemyList.AddRange (enemiesList);
+        }
+
+        List<GameObject> closestEnemyList = new List<GameObject> ();
+
+        for (int j = 0; j < fullEnemyList.Count; j++) {
+            if (!applyDamage.checkIfDead (fullEnemyList [j])) {
+                closestEnemyList.Add (fullEnemyList [j]);
+            }
+        }
+
+        if (closestEnemyList.Count > 0) {
+            float distance = Mathf.Infinity;
+
+            int index = -1;
+
+            for (int j = 0; j < closestEnemyList.Count; j++) {
+                float currentDistance = GKC_Utils.distance (closestEnemyList [j].transform.position, centerPosition);
+
+                if (currentDistance < distance) {
+                    distance = currentDistance;
+                    index = j;
+                }
+            }
+
+            if (index != -1) {
+                closestEnemy = closestEnemyList [index];
+
+                return closestEnemy.transform;
+            }
+        }
+
+        return null;
+    }
+    public Transform getClosestEnemyToScreenView ()
+    {
+        List<Collider> targetsListCollider = new List<Collider> ();
+
+        List<GameObject> targetList = new List<GameObject> ();
+        List<GameObject> fullTargetList = new List<GameObject> ();
+
+        List<Transform> targetsListToLookTransform = new List<Transform> ();
+
+        int tagToLocateCount = tagToLocate.Count;
+
+        for (int i = 0; i < tagToLocateCount; i++) {
+            GameObject [] enemiesList = GameObject.FindGameObjectsWithTag (tagToLocate [i]);
+            targetList.AddRange (enemiesList);
+        }
+
+        int targetListCount = targetList.Count;
+
+        for (int i = 0; i < targetListCount; i++) {
+            float distance = GKC_Utils.distance (targetList [i].transform.position, playerCameraTransform.position);
+
+            if (distance < maxDistanceToFindTarget) {
+                fullTargetList.Add (targetList [i]);
+            }
+        }
+
+        List<GameObject> pointToLookComponentList = new List<GameObject> ();
+
+        if (searchPointToLookComponents) {
+            targetsListCollider.Clear ();
+
+            targetsListCollider.AddRange (Physics.OverlapSphere (playerCameraTransform.position, maxDistanceToFindTarget, pointToLookComponentsLayer));
+
+            int targetsListColliderCount = targetsListCollider.Count;
+
+            for (int i = 0; i < targetsListColliderCount; i++) {
+                if (targetsListCollider [i].isTrigger) {
+                    pointToLook currentPointToLook = targetsListCollider [i].GetComponent<pointToLook> ();
+
+                    if (currentPointToLook != null) {
+                        if (currentPointToLook.isPointToLookEnabled ()) {
+                            GameObject currenTargetToLook = currentPointToLook.getPointToLookTransform ().gameObject;
+
+                            fullTargetList.Add (currenTargetToLook);
+
+                            pointToLookComponentList.Add (currenTargetToLook);
+                        }
+                    }
+                }
+            }
+        }
+
+        bool isUsingScreenSpaceCamera = mainPlayerCamera.isUsingScreenSpaceCamera ();
+
+        float screenWidth = Screen.width;
+        float screenHeight = Screen.height;
+
+        Vector3 screenPoint;
+
+        bool targetOnScreen;
+
+        int fullTargetListCount = fullTargetList.Count;
+
+        RaycastHit hit = new RaycastHit ();
+
+        for (int i = 0; i < fullTargetListCount; i++) {
+            if (fullTargetList [i] != null) {
+                GameObject currentTarget = fullTargetList [i];
+
+                if (tagToLocate.Contains (currentTarget.tag) || pointToLookComponentList.Contains (currentTarget)) {
+                    bool objectVisible = false;
+                    bool obstacleDetected = false;
+
+                    Vector3 targetPosition = currentTarget.transform.position;
+
+                    if (lookOnlyIfTargetOnScreen) {
+                        Transform currentTargetPlaceToShoot = applyDamage.getPlaceToShoot (currentTarget);
+
+                        if (currentTargetPlaceToShoot != null) {
+                            targetPosition = currentTargetPlaceToShoot.position;
+                        }
+
+                        if (isUsingScreenSpaceCamera) {
+                            screenPoint = mainCamera.WorldToViewportPoint (targetPosition);
+                            targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < 1 && screenPoint.y > 0 && screenPoint.y < 1;
+                        } else {
+                            screenPoint = mainCamera.WorldToScreenPoint (targetPosition);
+                            targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < screenWidth && screenPoint.y > 0 && screenPoint.y < screenHeight;
+                        }
+
+                        //the target is visible in the screen
+                        if (targetOnScreen) {
+                            objectVisible = true;
+                        }
+                    } else {
+                        objectVisible = true;
+                    }
+
+                    if (objectVisible && checkObstaclesToTarget) {
+                        //for every target in front of the camera, use a raycast, if it finds an obstacle between the target and the camera, the target is removed from the list
+                        Vector3 temporaltargetPosition = targetPosition;
+
+                        Transform temporalPlaceToShoot = applyDamage.getPlaceToShoot (currentTarget);
+
+                        if (temporalPlaceToShoot != null) {
+                            temporaltargetPosition = temporalPlaceToShoot.position;
+                        }
+
+                        Vector3 direction = temporaltargetPosition - mainCameraTransform.position;
+
+                        direction = direction / direction.magnitude;
+
+                        float distance = GKC_Utils.distance (temporaltargetPosition, mainCameraTransform.position);
+
+                        if (Physics.Raycast (temporaltargetPosition, -direction, out hit, distance, layerToLook)) {
+                            obstacleDetected = true;
+
+                            if (showCameraGizmo) {
+                                Debug.DrawLine (temporaltargetPosition, hit.point, Color.white, 4);
+                            }
+
+                            if (showDebugPrint) {
+                                print ("obstacle detected " + hit.collider.name + " " + currentTarget.name);
+                            }
+                        }
+                    }
+
+                    if (objectVisible && !obstacleDetected) {
+                        targetsListToLookTransform.Add (currentTarget.transform);
+                    }
+                }
+            }
+        }
+
+        //finally, get the target closest to the player
+        float minDistance = Mathf.Infinity;
+
+        Vector3 centerScreen = mainPlayerCamera.getScreenCenter ();
+
+        int targetsListToLookTransformCount = targetsListToLookTransform.Count;
+
+        Transform placeToShoot;
+
+        bool targetFound = false;
+
+        Transform targetToLook = null;
+
+        for (int i = 0; i < targetsListToLookTransformCount; i++) {
+
+            //find closes element to center screen
+            if (getClosestToCameraCenter) {
+                Vector3 targetPosition = targetsListToLookTransform [i].position;
+
+                placeToShoot = applyDamage.getPlaceToShoot (targetsListToLookTransform [i].gameObject);
+
+                if (placeToShoot != null) {
+                    targetPosition = placeToShoot.position;
+                }
+
+                screenPoint = mainCamera.WorldToScreenPoint (targetPosition);
+
+                //				print (screenPoint + " " + centerScreen);
+
+                float currentDistance = GKC_Utils.distance (screenPoint, centerScreen);
+
+                bool canBeChecked = false;
+
+                if (useMaxDistanceToCameraCenter) {
+                    if (currentDistance < maxDistanceToCameraCenter) {
+                        canBeChecked = true;
+                    }
+                } else {
+                    canBeChecked = true;
+                }
+
+                if (canBeChecked) {
+                    if (currentDistance < minDistance) {
+                        minDistance = currentDistance;
+
+                        targetToLook = targetsListToLookTransform [i];
+
+                        targetFound = true;
+                    }
+                }
+            } else {
+                float currentDistance = GKC_Utils.distance (targetsListToLookTransform [i].position, playerCameraTransform.position);
+
+                if (currentDistance < minDistance) {
+                    minDistance = currentDistance;
+
+                    targetToLook = targetsListToLookTransform [i];
+
+                    targetFound = true;
+                }
+            }
+        }
+
+        if (targetFound) {
+            //check if the object to check is too far from screen center in case the look at body parts on characters is active and no body part is found or is close enough to screen center
+            if (useMaxDistanceToCameraCenter && getClosestToCameraCenter) {
+                placeToShoot = applyDamage.getPlaceToShoot (targetToLook.gameObject);
+
+                if (placeToShoot == null) {
+                    placeToShoot = targetToLook;
+                }
+
+                screenPoint = mainCamera.WorldToScreenPoint (placeToShoot.position);
+
+                float currentDistance = GKC_Utils.distance (screenPoint, centerScreen);
+
+                if (currentDistance > maxDistanceToCameraCenter) {
+                    targetToLook = null;
+                    targetFound = false;
+
+                    //print ("cancel look at target");
+                }
+            }
+        }
+
+        if (showDebugPrint) {
+            if (targetFound) {
+                print ("target found " + targetToLook.name);
+            }
+        }
+
+        return targetToLook;
+    }
+}

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToUseAbility.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 120cf2735a1c6fb41bbf04a8709c33c4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure Creator 3D + 2.5D
+  packageVersion: 3.77g
+  assetPath: Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToUseAbility.cs
+  uploadId: 814740

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToWait.cs

@@ -0,0 +1,18 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class customOrderBehaviorToWait : customOrderBehavior
+{
+	public override void activateOrder (Transform character)
+	{
+
+
+	}
+
+
+	public override Transform getCustomTarget (Transform character, Transform orderOwner)
+	{
+		return orderOwner;
+	}
+}

Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToWait.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 6589a678eb5e28f4e898215801a58772
+timeCreated: 1670785082
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure Creator 3D + 2.5D
+  packageVersion: 3.77g
+  assetPath: Assets/Game Kit Controller/Scripts/AI/Custom Orders/customOrderBehaviorToWait.cs
+  uploadId: 814740