3122 lines
123 KiB
C#
3122 lines
123 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
using UnityEngine.EventSystems;
|
|
using UnityEngine.Events;
|
|
|
|
public class inventoryQuickAccessSlotsSystem : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public int numberQuickAccessSlots = 10;
|
|
|
|
public bool useInventoryQuickAccessSlots = true;
|
|
|
|
public float timeToDrag = 0.5f;
|
|
|
|
public bool useDragDropInventorySlots;
|
|
|
|
public bool hideEmptySlots;
|
|
|
|
[Space]
|
|
[Header ("Show Slots Settings")]
|
|
[Space]
|
|
|
|
public bool showQuickAccessSlotsAlways = true;
|
|
|
|
public bool keepQuickAccessSlotsHiddenOnMainScreen;
|
|
|
|
public float showQuickAccessSlotsParentDuration = 1;
|
|
public float quickAccessSlotsParentScale = 0.7f;
|
|
|
|
public bool setQuickAccessSlotsAlphaValueOutOfInventory;
|
|
public float quickAccessSlotsAlphaValueOutOfInventory;
|
|
|
|
[Space]
|
|
[Space]
|
|
|
|
public bool showQuickAccessSlotsWhenChangingSlot = true;
|
|
|
|
public bool showQuickAccessSlotSelectedIcon = true;
|
|
|
|
public bool swapInventoryObjectSlotsOnGridEnabled = true;
|
|
|
|
public float minTimeToSelectQuickAccessSlot = 0.4f;
|
|
|
|
public bool showSlotAmountEnabled = true;
|
|
|
|
public bool showSlotAmmoAmountEnabled = true;
|
|
|
|
public bool assignQuickAccesssSlotsOnNumberKeysOnInventoryOpenedEnabled;
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public bool disableQuickAccessSlotsWhenChangingFromFireWeaponsMode = false;
|
|
public bool disableQuickAccessSlotsWhenChangingFromMeleeWeaponsMode = false;
|
|
|
|
public bool holsterFireWeaponIfSlotAlreadySelected = true;
|
|
public bool sheatheMeleeWeaponsIfSlotAlreadySelected = true;
|
|
|
|
public bool changeAlwaysToWeaponWithoutDoubleSelection;
|
|
|
|
[Space]
|
|
[Header ("Input Settings")]
|
|
[Space]
|
|
|
|
public bool quickAccessInputNumberKeysEnabled = true;
|
|
public bool quickAccessInputMouseWheelActive;
|
|
public bool changeWeaponsWithKeysActive;
|
|
|
|
[Space]
|
|
|
|
public bool useEventsOnChangeWeaponsWithKeysActive;
|
|
public eventParameters.eventToCallWithBool eventsOnChangeWeaponsWithKeysActive;
|
|
|
|
[Space]
|
|
[Header ("Character Customization Slots Settings")]
|
|
[Space]
|
|
|
|
public List<GameObject> characterCustomizationSlotGameObjectList = new List<GameObject> ();
|
|
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
public bool currentObjectCanBeEquipped;
|
|
public bool currentObjectCanBeUsed;
|
|
|
|
public int currentSlotIndex;
|
|
|
|
public bool pressedObjecWithoutEquipOrUseProperty;
|
|
|
|
public bool draggedFromInventoryList;
|
|
public bool draggedFromQuickAccessSlots;
|
|
|
|
public bool inventoryOpened;
|
|
|
|
public bool customizingCharacterActive;
|
|
|
|
public bool checkObjectCategoriesToUseActive;
|
|
public List<string> currentCategoryListToUseActive = new List<string> ();
|
|
|
|
public bool checkSlotsCategoryNameToDrop;
|
|
|
|
public bool quickAccessInputNumberKeysPaused;
|
|
|
|
public bool changeOfWeaponsInProccess;
|
|
|
|
[Space]
|
|
[Header ("Quick Access Slots Debug")]
|
|
[Space]
|
|
|
|
public List<inventoryQuickAccessSlotElement.quickAccessSlotInfo> characterCustomizationSlotList = new List<inventoryQuickAccessSlotElement.quickAccessSlotInfo> ();
|
|
|
|
public List<inventoryQuickAccessSlotElement.quickAccessSlotInfo> quickAccessSlotInfoList = new List<inventoryQuickAccessSlotElement.quickAccessSlotInfo> ();
|
|
|
|
[Space]
|
|
[Header ("Events Settings")]
|
|
[Space]
|
|
|
|
public UnityEvent eventToSetFireWeaponsMode;
|
|
public UnityEvent eventToSetMeleeWeaponsMode;
|
|
|
|
[Space]
|
|
[Header ("UI Elements")]
|
|
[Space]
|
|
|
|
public GameObject slotPrefab;
|
|
|
|
public bool instantiateQuickSlotPrefabEnabled = true;
|
|
|
|
public List<GameObject> quickAccessSlotsList = new List<GameObject> ();
|
|
|
|
[Space]
|
|
|
|
public GameObject inventoryQuickAccessSlots;
|
|
|
|
public GameObject quickAccessSlotToMove;
|
|
|
|
public GameObject quickAccessSlotSelectedIcon;
|
|
|
|
public Transform quickAccessSlotsParentOnInventory;
|
|
public Transform quickAccessSlotsParentOutOfInventory;
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public inventoryManager mainInventoryManager;
|
|
|
|
public playerWeaponsManager mainPlayerWeaponsManager;
|
|
|
|
public meleeWeaponsGrabbedManager mainMeleeWeaponsGrabbedManager;
|
|
|
|
public playerInputManager playerInput;
|
|
|
|
|
|
bool touchPlatform;
|
|
|
|
Touch currentTouch;
|
|
|
|
bool touching;
|
|
|
|
readonly List<RaycastResult> captureRaycastResults = new List<RaycastResult> ();
|
|
|
|
float lastTimeTouched;
|
|
bool slotToMoveFound;
|
|
|
|
GameObject slotFoundOnDrop;
|
|
inventoryInfo currentSlotToMoveInventoryObject;
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo quickSlotFoundOnPress;
|
|
|
|
float currentTimeTime;
|
|
|
|
bool inventorySlotReadyToDrag;
|
|
|
|
bool activatingDualWeaponSlot;
|
|
|
|
string currentRighWeaponName;
|
|
string currentLeftWeaponName;
|
|
|
|
bool showQuickAccessSlotsPaused;
|
|
|
|
Coroutine slotsParentCouroutine;
|
|
|
|
List<inventoryInfo> inventoryList = new List<inventoryInfo> ();
|
|
|
|
float lastTimeQuickAccessSlotSelected;
|
|
|
|
int quickAccessSlotInfoListCount;
|
|
|
|
List<inventoryQuickAccessSlotElement.quickAccessSlotInfo> currentQuickAccessList = new List<inventoryQuickAccessSlotElement.quickAccessSlotInfo> ();
|
|
|
|
bool objectDetectedIsBroken;
|
|
|
|
bool selectingSlotByInputActive;
|
|
|
|
|
|
public void initializeQuickAccessSlots ()
|
|
{
|
|
GameObject newQuickAccessSlot = null;
|
|
|
|
if (instantiateQuickSlotPrefabEnabled) {
|
|
if (quickAccessSlotsList.Count == 0) {
|
|
instantiateQuickSlotPrefabEnabled = false;
|
|
} else {
|
|
numberQuickAccessSlots = quickAccessSlotsList.Count;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < numberQuickAccessSlots; i++) {
|
|
if (instantiateQuickSlotPrefabEnabled) {
|
|
newQuickAccessSlot = quickAccessSlotsList [i];
|
|
} else {
|
|
newQuickAccessSlot = (GameObject)Instantiate (slotPrefab, Vector3.zero, Quaternion.identity, slotPrefab.transform.parent);
|
|
}
|
|
|
|
newQuickAccessSlot.name = "Quick Access Slot " + (i + 1);
|
|
|
|
newQuickAccessSlot.transform.localScale = Vector3.one;
|
|
newQuickAccessSlot.transform.localPosition = Vector3.zero;
|
|
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentQuickAccessSlotInfo = newQuickAccessSlot.GetComponent<inventoryQuickAccessSlotElement> ().mainQuickAccessSlotInfo;
|
|
|
|
currentQuickAccessSlotInfo.Name = "";
|
|
currentQuickAccessSlotInfo.slotActive = false;
|
|
|
|
if (currentQuickAccessSlotInfo.slotMainSingleContent.activeSelf) {
|
|
currentQuickAccessSlotInfo.slotMainSingleContent.SetActive (false);
|
|
}
|
|
|
|
int index = i;
|
|
|
|
if (index == 9) {
|
|
index = -1;
|
|
}
|
|
|
|
currentQuickAccessSlotInfo.iconNumberKeyText.text = "[" + (index + 1) + "]";
|
|
|
|
quickAccessSlotInfoList.Add (currentQuickAccessSlotInfo);
|
|
|
|
if (hideEmptySlots) {
|
|
if (currentQuickAccessSlotInfo.slot.activeSelf) {
|
|
currentQuickAccessSlotInfo.slot.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
quickAccessSlotInfoListCount = quickAccessSlotInfoList.Count;
|
|
|
|
currentQuickAccessList = quickAccessSlotInfoList;
|
|
|
|
|
|
for (int i = 0; i < characterCustomizationSlotGameObjectList.Count; i++) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentQuickAccessSlotInfo = characterCustomizationSlotGameObjectList [i].GetComponent<inventoryQuickAccessSlotElement> ().mainQuickAccessSlotInfo;
|
|
|
|
characterCustomizationSlotList.Add (currentQuickAccessSlotInfo);
|
|
}
|
|
|
|
|
|
touchPlatform = touchJoystick.checkTouchPlatform ();
|
|
|
|
slotPrefab.SetActive (false);
|
|
|
|
if (useInventoryQuickAccessSlots) {
|
|
mainPlayerWeaponsManager.setChangeWeaponsWithNumberKeysActiveState (false);
|
|
mainPlayerWeaponsManager.setChangeWeaponsWithKeysActive (false);
|
|
} else {
|
|
setInventoryQuickAccessSlotsActiveState (false);
|
|
}
|
|
}
|
|
|
|
public void enableOrDisableAllQuickAccessSlots (bool state)
|
|
{
|
|
if (hideEmptySlots) {
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = quickAccessSlotInfoList [j];
|
|
|
|
if (state) {
|
|
if (currentSlotInfo.slot.activeSelf != state) {
|
|
currentSlotInfo.slot.SetActive (state);
|
|
}
|
|
} else {
|
|
if (!currentSlotInfo.slotActive) {
|
|
if (currentSlotInfo.slot.activeSelf != state) {
|
|
currentSlotInfo.slot.SetActive (state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setOnQuickSlotsCurrentObjectDirectly (inventoryInfo currentInventoryInfo, int quickAccessSlotIndex)
|
|
{
|
|
if (currentInventoryInfo == null) {
|
|
return;
|
|
}
|
|
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = null;
|
|
|
|
if (quickAccessSlotIndex > -1) {
|
|
currentSlotInfo = currentQuickAccessList [quickAccessSlotIndex];
|
|
|
|
if (!currentSlotInfo.slotActive) {
|
|
slotFoundOnDrop = currentSlotInfo.slot;
|
|
} else {
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
}
|
|
} else {
|
|
|
|
quickAccessSlotInfoListCount = quickAccessSlotInfoList.Count;
|
|
|
|
bool emptyQuickAccessSlotFound = false;
|
|
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
if (!emptyQuickAccessSlotFound) {
|
|
currentSlotInfo = quickAccessSlotInfoList [j];
|
|
|
|
if (!currentSlotInfo.slotActive) {
|
|
emptyQuickAccessSlotFound = true;
|
|
|
|
slotFoundOnDrop = currentSlotInfo.slot;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!emptyQuickAccessSlotFound) {
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (currentInventoryInfo.isWeapon) {
|
|
if (mainMeleeWeaponsGrabbedManager.isCarryingRegularPhysicalObject ()) {
|
|
resetDragAndDropSlotState ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("character is carrying a physical regular object, cancelling check");
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
currentObjectCanBeEquipped = false;
|
|
currentObjectCanBeUsed = false;
|
|
|
|
pressedObjecWithoutEquipOrUseProperty = false;
|
|
|
|
objectDetectedIsBroken = false;
|
|
|
|
bool checkDurabilityOnObjectEnabled = mainInventoryManager.checkDurabilityOnObjectEnabled;
|
|
|
|
currentObjectCanBeEquipped = currentInventoryInfo.canBeEquiped;
|
|
currentObjectCanBeUsed = currentInventoryInfo.canBeUsed;
|
|
|
|
bool canBePlaceOnQuickAccessSlot = currentInventoryInfo.canBePlaceOnQuickAccessSlot;
|
|
|
|
if (showDebugPrint) {
|
|
print ("inventory object pressed " + currentInventoryInfo.Name + " " + currentObjectCanBeEquipped + " " + currentObjectCanBeUsed);
|
|
}
|
|
|
|
bool slotCanBeSelected = false;
|
|
|
|
if (currentObjectCanBeEquipped) {
|
|
slotCanBeSelected = true;
|
|
|
|
if (showDebugPrint) {
|
|
print ("slot Can Be Selected " + slotCanBeSelected);
|
|
}
|
|
}
|
|
|
|
if (currentObjectCanBeUsed) {
|
|
slotCanBeSelected = true;
|
|
|
|
if (showDebugPrint) {
|
|
print ("slot Can Be Selected " + slotCanBeSelected);
|
|
}
|
|
}
|
|
|
|
if (canBePlaceOnQuickAccessSlot) {
|
|
slotCanBeSelected = true;
|
|
|
|
if (showDebugPrint) {
|
|
print ("slot Can Be Selected " + slotCanBeSelected);
|
|
}
|
|
} else {
|
|
slotCanBeSelected = false;
|
|
|
|
if (showDebugPrint) {
|
|
print ("slot Can Be Selected " + slotCanBeSelected);
|
|
}
|
|
}
|
|
|
|
if (checkObjectCategoriesToUseActive) {
|
|
if (!currentCategoryListToUseActive.Contains (currentInventoryInfo.categoryName)) {
|
|
slotCanBeSelected = false;
|
|
|
|
if (showDebugPrint) {
|
|
print ("slot Can Be Selected " + slotCanBeSelected);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (checkDurabilityOnObjectEnabled) {
|
|
if (slotCanBeSelected) {
|
|
if (currentInventoryInfo.objectIsBroken) {
|
|
if (mainInventoryManager.brokenObjectsCantBeEquipped) {
|
|
slotCanBeSelected = false;
|
|
|
|
if (showDebugPrint) {
|
|
print ("slot Can Be Selected " + slotCanBeSelected);
|
|
}
|
|
|
|
objectDetectedIsBroken = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (slotCanBeSelected) {
|
|
if (showDebugPrint) {
|
|
print ("slot Selected ");
|
|
}
|
|
|
|
currentSlotToMoveInventoryObject = currentInventoryInfo;
|
|
|
|
slotToMoveFound = true;
|
|
|
|
draggedFromInventoryList = true;
|
|
|
|
checkDroppedSlot ();
|
|
}
|
|
}
|
|
|
|
public void updateInventoryOpenedState ()
|
|
{
|
|
if (useDragDropInventorySlots && !mainInventoryManager.examiningObject) {
|
|
int touchCount = Input.touchCount;
|
|
if (!touchPlatform) {
|
|
touchCount++;
|
|
}
|
|
|
|
currentTimeTime = mainInventoryManager.getTimeTime ();
|
|
|
|
for (int i = 0; i < touchCount; i++) {
|
|
if (!touchPlatform) {
|
|
currentTouch = touchJoystick.convertMouseIntoFinger ();
|
|
} else {
|
|
currentTouch = Input.GetTouch (i);
|
|
}
|
|
|
|
if (currentTouch.phase == TouchPhase.Began && !touching) {
|
|
touching = true;
|
|
|
|
lastTimeTouched = currentTimeTime;
|
|
|
|
captureRaycastResults.Clear ();
|
|
|
|
PointerEventData p = new PointerEventData (EventSystem.current);
|
|
p.position = currentTouch.position;
|
|
p.clickCount = i;
|
|
p.dragging = false;
|
|
|
|
EventSystem.current.RaycastAll (p, captureRaycastResults);
|
|
|
|
foreach (RaycastResult r in captureRaycastResults) {
|
|
|
|
inventorySlotOptionsButtons currentInventorySlotOptionsButtons = r.gameObject.GetComponent<inventorySlotOptionsButtons> ();
|
|
|
|
if (currentInventorySlotOptionsButtons != null) {
|
|
if (showDebugPrint) {
|
|
print ("InventorySlotOptionsButtons found, ignoring the rest of UI elements below");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
simpleInventorySlotOptionsButton currentsimpleInventorySlotOptionsButton = r.gameObject.GetComponent<simpleInventorySlotOptionsButton> ();
|
|
|
|
if (currentsimpleInventorySlotOptionsButton != null) {
|
|
if (showDebugPrint) {
|
|
print ("Simple InventorySlotOptionsButton found, ignoring the rest of UI elements below");
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
foreach (RaycastResult r in captureRaycastResults) {
|
|
if (!slotToMoveFound) {
|
|
currentObjectCanBeEquipped = false;
|
|
currentObjectCanBeUsed = false;
|
|
|
|
pressedObjecWithoutEquipOrUseProperty = false;
|
|
|
|
objectDetectedIsBroken = false;
|
|
|
|
inventoryMenuIconElement currentInventoryMenuIconElement = r.gameObject.GetComponent<inventoryMenuIconElement> ();
|
|
|
|
inventoryQuickAccessSlotElement currentQuickAccessSlotInfo = r.gameObject.GetComponent<inventoryQuickAccessSlotElement> ();
|
|
|
|
if (currentInventoryMenuIconElement != null) {
|
|
bool checkDurabilityOnObjectEnabled = mainInventoryManager.checkDurabilityOnObjectEnabled;
|
|
|
|
inventoryList = mainInventoryManager.inventoryList;
|
|
|
|
int inventoryListCount = inventoryList.Count;
|
|
|
|
for (int j = 0; j < inventoryListCount; j++) {
|
|
inventoryInfo currentInventoryInfo = inventoryList [j];
|
|
|
|
if (currentInventoryInfo.amount > 0 && currentInventoryInfo.button == currentInventoryMenuIconElement.button) {
|
|
currentObjectCanBeEquipped = currentInventoryInfo.canBeEquiped;
|
|
currentObjectCanBeUsed = currentInventoryInfo.canBeUsed;
|
|
|
|
bool canBePlaceOnQuickAccessSlot = currentInventoryInfo.canBePlaceOnQuickAccessSlot;
|
|
|
|
if (showDebugPrint) {
|
|
print ("inventory object pressed " + currentInventoryInfo.Name + " " + currentObjectCanBeEquipped + " " + currentObjectCanBeUsed);
|
|
}
|
|
|
|
bool slotCanBeSelected = false;
|
|
|
|
if (currentObjectCanBeEquipped) {
|
|
slotCanBeSelected = true;
|
|
}
|
|
|
|
if (currentObjectCanBeUsed) {
|
|
slotCanBeSelected = true;
|
|
}
|
|
|
|
if (canBePlaceOnQuickAccessSlot) {
|
|
slotCanBeSelected = true;
|
|
} else {
|
|
slotCanBeSelected = false;
|
|
}
|
|
|
|
if (checkObjectCategoriesToUseActive) {
|
|
if (!currentCategoryListToUseActive.Contains (currentInventoryInfo.categoryName)) {
|
|
slotCanBeSelected = false;
|
|
}
|
|
}
|
|
|
|
if (checkDurabilityOnObjectEnabled) {
|
|
if (slotCanBeSelected) {
|
|
if (currentInventoryInfo.objectIsBroken) {
|
|
if (mainInventoryManager.brokenObjectsCantBeEquipped) {
|
|
slotCanBeSelected = false;
|
|
|
|
objectDetectedIsBroken = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (slotCanBeSelected) {
|
|
currentSlotToMoveInventoryObject = currentInventoryInfo;
|
|
|
|
slotToMoveFound = true;
|
|
|
|
draggedFromInventoryList = true;
|
|
} else {
|
|
if (swapInventoryObjectSlotsOnGridEnabled && !customizingCharacterActive) {
|
|
pressedObjecWithoutEquipOrUseProperty = true;
|
|
|
|
currentSlotToMoveInventoryObject = currentInventoryInfo;
|
|
|
|
slotToMoveFound = true;
|
|
|
|
draggedFromInventoryList = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (currentQuickAccessSlotInfo != null) {
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [j];
|
|
|
|
if (currentSlotInfo.slot == currentQuickAccessSlotInfo.mainQuickAccessSlotInfo.slot) {
|
|
if (currentSlotInfo.slotActive) {
|
|
quickSlotFoundOnPress = currentSlotInfo;
|
|
|
|
slotToMoveFound = true;
|
|
|
|
draggedFromQuickAccessSlots = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (slotToMoveFound) {
|
|
RawImage slotToMoveRawImage = quickAccessSlotToMove.GetComponentInChildren<RawImage> ();
|
|
|
|
if (draggedFromInventoryList) {
|
|
slotToMoveRawImage.texture = currentInventoryMenuIconElement.icon.texture;
|
|
}
|
|
|
|
if (draggedFromQuickAccessSlots) {
|
|
if (currentQuickAccessSlotInfo.mainQuickAccessSlotInfo.secondarySlotActive) {
|
|
slotToMoveRawImage.texture = currentQuickAccessSlotInfo.mainQuickAccessSlotInfo.leftSecondarySlotIcon.texture;
|
|
} else {
|
|
slotToMoveRawImage.texture = currentQuickAccessSlotInfo.mainQuickAccessSlotInfo.slotIcon.texture;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((currentTouch.phase == TouchPhase.Stationary || currentTouch.phase == TouchPhase.Moved) && touching) {
|
|
if (slotToMoveFound) {
|
|
if (touching && currentTimeTime > lastTimeTouched + timeToDrag) {
|
|
if (!quickAccessSlotToMove.activeSelf) {
|
|
quickAccessSlotToMove.SetActive (true);
|
|
}
|
|
|
|
inventorySlotReadyToDrag = true;
|
|
|
|
quickAccessSlotToMove.GetComponent<RectTransform> ().position = new Vector2 (currentTouch.position.x, currentTouch.position.y);
|
|
}
|
|
}
|
|
}
|
|
|
|
//if the mouse/finger press is released, then
|
|
if (currentTouch.phase == TouchPhase.Ended && touching) {
|
|
touching = false;
|
|
|
|
if (slotToMoveFound && inventorySlotReadyToDrag) {
|
|
//get the elements in the position where the player released the power element
|
|
captureRaycastResults.Clear ();
|
|
|
|
PointerEventData p = new PointerEventData (EventSystem.current);
|
|
p.position = currentTouch.position;
|
|
p.clickCount = i;
|
|
p.dragging = false;
|
|
EventSystem.current.RaycastAll (p, captureRaycastResults);
|
|
|
|
bool checkingToSwapObjectsPositionOnGrid = false;
|
|
|
|
foreach (RaycastResult r in captureRaycastResults) {
|
|
if (r.gameObject != quickAccessSlotToMove) {
|
|
if (r.gameObject.GetComponent<inventoryQuickAccessSlotElement> ()) {
|
|
slotFoundOnDrop = r.gameObject;
|
|
} else if (r.gameObject.GetComponent<inventoryMenuIconElement> ()) {
|
|
slotFoundOnDrop = r.gameObject;
|
|
|
|
if (swapInventoryObjectSlotsOnGridEnabled) {
|
|
if (draggedFromInventoryList) {
|
|
checkingToSwapObjectsPositionOnGrid = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (checkingToSwapObjectsPositionOnGrid) {
|
|
swapInventoryObjectsPositionOnGrid ();
|
|
} else {
|
|
checkDroppedSlot ();
|
|
}
|
|
} else {
|
|
resetDragAndDropSlotState ();
|
|
}
|
|
|
|
inventorySlotReadyToDrag = false;
|
|
|
|
slotToMoveFound = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void swapInventoryObjectsPositionOnGrid ()
|
|
{
|
|
if (draggedFromInventoryList) {
|
|
if (slotFoundOnDrop != null) {
|
|
if (showDebugPrint) {
|
|
print ("checking to swap objects slots on the grid");
|
|
}
|
|
|
|
inventoryMenuIconElement currentInventoryMenuIconElement = slotFoundOnDrop.GetComponent<inventoryMenuIconElement> ();
|
|
|
|
if (currentInventoryMenuIconElement != null) {
|
|
|
|
inventoryList = mainInventoryManager.inventoryList;
|
|
|
|
bool objectsSwaped = false;
|
|
|
|
int inventoryListCount = inventoryList.Count;
|
|
|
|
for (int j = 0; j < inventoryListCount; j++) {
|
|
if (!objectsSwaped) {
|
|
inventoryInfo currentInventoryInfo = inventoryList [j];
|
|
|
|
if (currentInventoryInfo.button == currentInventoryMenuIconElement.button) {
|
|
if (showDebugPrint) {
|
|
print ("slot wih object " + currentSlotToMoveInventoryObject.Name + " dragged from inventory grid dropped into " + currentInventoryInfo.Name);
|
|
}
|
|
|
|
if (currentSlotToMoveInventoryObject != currentInventoryInfo) {
|
|
int slotToMoveIndex1 = mainInventoryManager.getInventoryObjectIndexByInventoryInfo (currentSlotToMoveInventoryObject);
|
|
|
|
int slotToMoveIndex2 = j;
|
|
|
|
if (slotToMoveIndex1 != -1 && slotToMoveIndex2 != -1) {
|
|
|
|
inventoryList [slotToMoveIndex1] = currentInventoryInfo;
|
|
|
|
inventoryList [slotToMoveIndex2] = currentSlotToMoveInventoryObject;
|
|
|
|
|
|
mainInventoryManager.updateFullInventorySlots ();
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("item 1 or 2 not found when trying to swap slots on inventory grid, cancelling swap");
|
|
}
|
|
}
|
|
|
|
objectsSwaped = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
resetDragAndDropSlotState ();
|
|
}
|
|
|
|
public void checkDroppedSlot ()
|
|
{
|
|
//SITUATIONS THAT CAN HAPPEN WHEN DROPPING A SLOT
|
|
|
|
//---PRESSING IN THE INVENTORY GRID
|
|
|
|
//DROPPING OUT OF THE INVENTORY-No action
|
|
//DROPPING IN THE INVENTORY GRID-No action
|
|
//DROPPING IN THE QUICK ACCESS SLOTS:
|
|
//DROPPING FIRE WEAPON-
|
|
//DROPPING MELEE WEAPON-
|
|
//DROPPING REGULAR OBJECT-
|
|
|
|
//THE QUICK ACCESS SLOT DETECTED IN DROP IS:
|
|
//_EMPTY-Assign inventory object there
|
|
//_NOT EMPTY-If regular object, replace-If melee weapon, replace-If fire weapon, check to combine
|
|
//If the slot was already on the quick access slots, move of place
|
|
//If the object can be equipped, equip it
|
|
//If there was a previous object equipped on it, unequip it
|
|
|
|
//---PRESSING IN THE QUICK ACCESS SLOTS
|
|
|
|
//DROPPPING OUT OF THE INVENTORY-Clean quick access slot
|
|
//DROPPING IN THE QUICK ACCESS SLOTS:
|
|
//DROPPING FIRE WEAPON-
|
|
//DROPPING MELEE WEAPON-
|
|
//DROPPING REGULAR OBJECT-
|
|
|
|
//THE QUICK ACCESS SLOT DETECTED IN DROP IS:
|
|
//_EMPTY-Move inventory object from previous quick access slot to new one
|
|
//_NOT EMPTY-If regular object, replace-If melee weapon, replace-If fire weapon, replace
|
|
//If the object can be equipped, equip it
|
|
//If there was a previous object equipped on it, unequip it
|
|
|
|
|
|
//A quick access slots has been found when dropping the pressed inventory/quick access slot
|
|
//and the pressed slot is not a quick access or hasn't a secondary object assigned
|
|
|
|
if (pressedObjecWithoutEquipOrUseProperty || objectDetectedIsBroken) {
|
|
if (showDebugPrint) {
|
|
print ("current object selected can't be equipped or used, so only swap position with another slots in the inventory grid is allowed");
|
|
}
|
|
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
}
|
|
|
|
if (slotFoundOnDrop != null && (quickSlotFoundOnPress == null || !quickSlotFoundOnPress.secondarySlotActive)) {
|
|
bool slotDroppedFoundOnQuickAccessList = false;
|
|
|
|
int slotFoundOnDropIndex = -1;
|
|
|
|
activatingDualWeaponSlot = false;
|
|
|
|
bool activateDualWeaponsEnabled = mainPlayerWeaponsManager.isActivateDualWeaponsEnabled ();
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
if (draggedFromInventoryList || draggedFromQuickAccessSlots) {
|
|
if (showDebugPrint) {
|
|
if (draggedFromInventoryList) {
|
|
print ("dragged from Inventory List to quick access slots");
|
|
}
|
|
|
|
if (draggedFromQuickAccessSlots) {
|
|
print ("dragged from quick access slots to unequip or change object");
|
|
}
|
|
}
|
|
|
|
inventoryQuickAccessSlotElement slotElementFoundOnDrop = slotFoundOnDrop.GetComponent<inventoryQuickAccessSlotElement> ();
|
|
|
|
//the slot pressed has been dropped in the quick access slots
|
|
if (slotElementFoundOnDrop != null) {
|
|
//Make initial checks on the slots pressed and dropped
|
|
if (draggedFromInventoryList) {
|
|
if (slotElementFoundOnDrop.mainQuickAccessSlotInfo.secondarySlotActive) {
|
|
if (showDebugPrint) {
|
|
print ("The weapon slot where you are trying to combine the weapon " + currentSlotToMoveInventoryObject.mainWeaponObjectInfo.getWeaponName () +
|
|
" is already active as dual weapon slot");
|
|
}
|
|
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
} else {
|
|
if (currentSlotToMoveInventoryObject.isWeapon) {
|
|
if (showDebugPrint) {
|
|
print ("using a weapon slot");
|
|
}
|
|
|
|
bool isMeleeWeapon = currentSlotToMoveInventoryObject.isMeleeWeapon;
|
|
|
|
if (mainInventoryManager.checkLimitOnEquipWeapon ()) {
|
|
if (slotElementFoundOnDrop.mainQuickAccessSlotInfo.slotActive) {
|
|
|
|
bool currentSlotFoundOnDropIsFireWeapon = !slotElementFoundOnDrop.mainQuickAccessSlotInfo.inventoryInfoAssigned.isMeleeWeapon;
|
|
|
|
if (!isMeleeWeapon && currentSlotFoundOnDropIsFireWeapon) {
|
|
if (activateDualWeaponsEnabled) {
|
|
if (showDebugPrint) {
|
|
print ("maximum number of weapons equipped, reseting slots state");
|
|
}
|
|
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (isMeleeWeapon && !currentSlotFoundOnDropIsFireWeapon) {
|
|
if (showDebugPrint) {
|
|
print ("maximum number of weapons equipped, reseting slots state");
|
|
}
|
|
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
}
|
|
|
|
if (isMeleeWeapon && currentSlotFoundOnDropIsFireWeapon) {
|
|
if (showDebugPrint) {
|
|
print ("maximum number of weapons equipped, reseting slots state");
|
|
}
|
|
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("maximum number of weapons equipped, reseting slots state");
|
|
}
|
|
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
if (!isMeleeWeapon) {
|
|
if (showDebugPrint) {
|
|
print ("using a fire weapon slot");
|
|
}
|
|
|
|
string weaponNameToEquip = currentSlotToMoveInventoryObject.mainWeaponObjectInfo.getWeaponName ();
|
|
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [j];
|
|
|
|
if (currentSlotInfo.secondarySlotActive) {
|
|
if (currentSlotInfo.firstElementName.Equals (weaponNameToEquip) || currentSlotInfo.secondElementName.Equals (weaponNameToEquip)) {
|
|
if (showDebugPrint) {
|
|
print ("The weapon slot where you are trying to combine the weapon " +
|
|
currentSlotToMoveInventoryObject.mainWeaponObjectInfo.getWeaponName () +
|
|
" is already active as dual weapon slot in another slot");
|
|
}
|
|
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
if (isMeleeWeapon) {
|
|
print ("using a melee weapon slot");
|
|
}
|
|
}
|
|
} else {
|
|
if (currentSlotToMoveInventoryObject.isArmorClothAccessory) {
|
|
if (checkSlotsCategoryNameToDrop) {
|
|
GameObject currentInventoryGameObject = mainInventoryManager.getInventoryPrefab (currentSlotToMoveInventoryObject.inventoryGameObject);
|
|
|
|
if (currentInventoryGameObject != null) {
|
|
|
|
armorClothPickup currentPickupObject = currentInventoryGameObject.GetComponent<armorClothPickup> ();
|
|
|
|
if (currentPickupObject != null) {
|
|
|
|
string currentSlotCategoryName = currentPickupObject.categoryName;
|
|
|
|
string currentSlotFoundOnDropName = slotElementFoundOnDrop.mainQuickAccessSlotInfo.slotCategoryName;
|
|
|
|
if (currentSlotFoundOnDropName != "") {
|
|
if (showDebugPrint) {
|
|
print ("Current category to check " + currentSlotCategoryName +
|
|
" and current category slot found " + currentSlotFoundOnDropName);
|
|
}
|
|
|
|
if (!currentSlotFoundOnDropName.Equals (currentSlotCategoryName)) {
|
|
|
|
if (showDebugPrint) {
|
|
print ("slot dropped is not the same category as the slot found for " +
|
|
currentSlotFoundOnDropName + " cancelling drop object into slot");
|
|
}
|
|
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (!customizingCharacterActive) {
|
|
if (showDebugPrint) {
|
|
print ("trying to drop an armor cloth piece into the regular quick access slots, canceling");
|
|
}
|
|
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("slot moved is object to use, like quest, or consumable, etc....");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//The slot dropped was already in the quick access slots
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
if (currentQuickAccessList [j].slot == slotElementFoundOnDrop.mainQuickAccessSlotInfo.slot) {
|
|
slotDroppedFoundOnQuickAccessList = true;
|
|
slotFoundOnDropIndex = j;
|
|
}
|
|
}
|
|
|
|
//check that the current weapon slot added is not already present in the list, in that case, reset that slot to update with the new one
|
|
if (draggedFromInventoryList) {
|
|
//Check if the use of dual weapons is disabled, to avoid to combine fire weapons
|
|
// if (!activateDualWeaponsEnabled && slotDroppedFoundOnQuickAccessList) {
|
|
// if (slotElementFoundOnDrop.mainQuickAccessSlotInfo.slotActive) {
|
|
// if (slotElementFoundOnDrop.mainQuickAccessSlotInfo.inventoryInfoAssigned.isWeapon &&
|
|
// !slotElementFoundOnDrop.mainQuickAccessSlotInfo.inventoryInfoAssigned.isMeleeWeapon) {
|
|
//
|
|
// if (showDebugPrint) {
|
|
// print ("Use of dual weapons is disabled, cancelling action");
|
|
// }
|
|
//
|
|
// resetDragAndDropSlotState ();
|
|
//
|
|
// return;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
//Reseting the info of the quick access slot that is assigned to the inventory slot pressed
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [i];
|
|
|
|
if (currentSlotInfo.slotActive && currentSlotInfo.Name.Equals (currentSlotToMoveInventoryObject.Name)) {
|
|
updateQuickAccessSlotInfo (-1, null, currentSlotInfo, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Check if the object was pressed from the quick access slots
|
|
if (draggedFromQuickAccessSlots) {
|
|
//The slot is droppend is already on the quick access slots, so it is being moved from one place to another
|
|
if (slotDroppedFoundOnQuickAccessList) {
|
|
if (quickSlotFoundOnPress == slotElementFoundOnDrop.mainQuickAccessSlotInfo) {
|
|
if (showDebugPrint) {
|
|
print ("moving object slot to the same place, nothing to do");
|
|
}
|
|
|
|
|
|
} else {
|
|
string currentObjectName = quickSlotFoundOnPress.inventoryInfoAssigned.Name;
|
|
|
|
if (showDebugPrint) {
|
|
print ("Object slot " + currentObjectName + " changed to " +
|
|
"replace " + slotElementFoundOnDrop.mainQuickAccessSlotInfo.Name);
|
|
}
|
|
|
|
if (quickSlotFoundOnPress.inventoryInfoAssigned.isWeapon) {
|
|
bool isMeleeWeapon = quickSlotFoundOnPress.inventoryInfoAssigned.isMeleeWeapon;
|
|
|
|
if (!isMeleeWeapon) {
|
|
|
|
mainPlayerWeaponsManager.unequipWeapon (slotElementFoundOnDrop.mainQuickAccessSlotInfo.Name, false, true);
|
|
|
|
mainPlayerWeaponsManager.selectWeaponByName (currentObjectName, true);
|
|
|
|
updateQuickAccessSlotInfo (slotFoundOnDropIndex, quickSlotFoundOnPress.inventoryInfoAssigned, null, null);
|
|
}
|
|
|
|
if (isMeleeWeapon) {
|
|
mainMeleeWeaponsGrabbedManager.unEquipMeleeWeapon (slotElementFoundOnDrop.mainQuickAccessSlotInfo.Name, false);
|
|
|
|
mainMeleeWeaponsGrabbedManager.equipMeleeWeapon (currentObjectName, false, false);
|
|
|
|
updateQuickAccessSlotInfo (slotFoundOnDropIndex, quickSlotFoundOnPress.inventoryInfoAssigned, null, null);
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("slot moved is object to use, like quest, or consumable, etc....");
|
|
|
|
print ("assign regular inventory object to quick access slot");
|
|
}
|
|
|
|
updateQuickAccessSlotInfo (slotFoundOnDropIndex, currentSlotToMoveInventoryObject, null, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Reseting the info of the quick access slot that is assigned to the quick access slot pressed
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [i];
|
|
|
|
if (slotFoundOnDropIndex != i && currentSlotInfo.slotActive && currentSlotInfo.Name.Equals (quickSlotFoundOnPress.Name)) {
|
|
updateQuickAccessSlotInfo (-1, null, currentSlotInfo, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (draggedFromInventoryList) {
|
|
//The slot found on drop is already active, so replace it or combine dual wepaons
|
|
if (slotElementFoundOnDrop.mainQuickAccessSlotInfo.slotActive) {
|
|
if (currentSlotToMoveInventoryObject.isWeapon) {
|
|
bool isMeleeWeapon = currentSlotToMoveInventoryObject.isMeleeWeapon;
|
|
|
|
bool currentSlotFoundOnDropIsFireWeapon = !slotElementFoundOnDrop.mainQuickAccessSlotInfo.inventoryInfoAssigned.isMeleeWeapon;
|
|
|
|
if (!isMeleeWeapon) {
|
|
bool replaceForMeleeWeaponResult = false;
|
|
|
|
if (activateDualWeaponsEnabled) {
|
|
if (currentSlotFoundOnDropIsFireWeapon) {
|
|
currentRighWeaponName = currentSlotToMoveInventoryObject.mainWeaponObjectInfo.getWeaponName ();
|
|
currentLeftWeaponName = slotElementFoundOnDrop.mainQuickAccessSlotInfo.inventoryInfoAssigned.mainWeaponObjectInfo.getWeaponName ();
|
|
|
|
mainInventoryManager.setCurrentRighWeaponNameValue (currentRighWeaponName);
|
|
mainInventoryManager.setCurrentLeftWeaponNameValue (currentLeftWeaponName);
|
|
|
|
if (mainPlayerWeaponsManager.checkIfWeaponIsOnSamePocket (currentRighWeaponName, currentLeftWeaponName)) {
|
|
if (showDebugPrint) {
|
|
print ("trying to equip dual weapons from the same weapon pocket, combine weapons cancelled");
|
|
}
|
|
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("equipping dual weapon");
|
|
}
|
|
|
|
activatingDualWeaponSlot = true;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
playerWeaponSystem currentPlayerWeaponSystem = mainPlayerWeaponsManager.getWeaponSystemByName (slotElementFoundOnDrop.mainQuickAccessSlotInfo.inventoryInfoAssigned.mainWeaponObjectInfo.getWeaponName ());
|
|
|
|
updateQuickAccessSlotInfo (slotFoundOnDropIndex, currentSlotToMoveInventoryObject, null, currentPlayerWeaponSystem);
|
|
|
|
mainInventoryManager.setCurrentInventoryObject (currentSlotToMoveInventoryObject);
|
|
|
|
mainInventoryManager.equipCurrentObject ();
|
|
} else {
|
|
replaceForMeleeWeaponResult = true;
|
|
}
|
|
} else {
|
|
if (currentSlotFoundOnDropIsFireWeapon) {
|
|
mainPlayerWeaponsManager.unequipWeapon (slotElementFoundOnDrop.mainQuickAccessSlotInfo.Name, false, true);
|
|
|
|
mainPlayerWeaponsManager.selectWeaponByName (currentSlotToMoveInventoryObject.mainWeaponObjectInfo.getWeaponName (), true);
|
|
|
|
updateQuickAccessSlotInfo (slotFoundOnDropIndex, currentSlotToMoveInventoryObject, null, null);
|
|
} else {
|
|
replaceForMeleeWeaponResult = true;
|
|
}
|
|
}
|
|
|
|
if (replaceForMeleeWeaponResult) {
|
|
mainMeleeWeaponsGrabbedManager.unEquipMeleeWeapon (slotElementFoundOnDrop.mainQuickAccessSlotInfo.Name, false);
|
|
|
|
mainInventoryManager.unEquipObjectByName (slotElementFoundOnDrop.mainQuickAccessSlotInfo.Name);
|
|
}
|
|
}
|
|
|
|
if (isMeleeWeapon) {
|
|
mainMeleeWeaponsGrabbedManager.unEquipMeleeWeapon (slotElementFoundOnDrop.mainQuickAccessSlotInfo.Name, false);
|
|
|
|
mainMeleeWeaponsGrabbedManager.equipMeleeWeapon (currentSlotToMoveInventoryObject.Name, false, false);
|
|
|
|
updateQuickAccessSlotInfo (slotFoundOnDropIndex, currentSlotToMoveInventoryObject, null, null);
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("slot moved is object to use, like quest, or consumable, etc....");
|
|
|
|
print ("assign regular inventory object to quick access slot");
|
|
}
|
|
|
|
if (slotElementFoundOnDrop.mainQuickAccessSlotInfo.inventoryInfoAssigned.canBeEquiped) {
|
|
mainInventoryManager.setCurrentInventoryObject (slotElementFoundOnDrop.mainQuickAccessSlotInfo.inventoryInfoAssigned);
|
|
|
|
mainInventoryManager.unEquipCurrentObject ();
|
|
}
|
|
|
|
updateQuickAccessSlotInfo (slotFoundOnDropIndex, currentSlotToMoveInventoryObject, null, null);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//The slot droppped was already on the quick access slots
|
|
if (slotDroppedFoundOnQuickAccessList) {
|
|
//the slot was press on the inventory grid
|
|
if (draggedFromInventoryList && !activatingDualWeaponSlot) {
|
|
//checking to equip the current object
|
|
if (currentSlotToMoveInventoryObject.canBeEquiped) {
|
|
if (!currentSlotToMoveInventoryObject.isArmorClothAccessory) {
|
|
updateQuickAccessSlotInfo (slotFoundOnDropIndex, currentSlotToMoveInventoryObject, null, null);
|
|
}
|
|
|
|
mainInventoryManager.setCurrentInventoryObject (currentSlotToMoveInventoryObject);
|
|
|
|
mainInventoryManager.equipCurrentObject ();
|
|
|
|
//if (currentSlotToMoveInventoryObject.isArmorClothAccessory) {
|
|
//updateQuickAccessSlotInfo (slotFoundOnDropIndex, currentSlotToMoveInventoryObject, null, null);
|
|
// }
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("slot moved is object to use, like quest, or consumable, etc....");
|
|
}
|
|
|
|
updateQuickAccessSlotInfo (slotFoundOnDropIndex, currentSlotToMoveInventoryObject, null, null);
|
|
|
|
}
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("dropped correctly");
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("dropped outside the list");
|
|
}
|
|
|
|
//the pressed slot has been dropped outside, so remove its info and unequip if possible
|
|
if (quickSlotFoundOnPress != null) {
|
|
if (quickSlotFoundOnPress.secondarySlotActive) {
|
|
if (showDebugPrint) {
|
|
print ("Dual weapon " + quickSlotFoundOnPress.inventoryInfoAssigned.mainWeaponObjectInfo.getWeaponName () + " removed");
|
|
}
|
|
|
|
activatingDualWeaponSlot = true;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
mainPlayerWeaponsManager.unequipWeapon (quickSlotFoundOnPress.secondElementName, activatingDualWeaponSlot, true);
|
|
} else {
|
|
if (quickSlotFoundOnPress.inventoryInfoAssigned.isWeapon) {
|
|
bool isMeleeWeapon = quickSlotFoundOnPress.inventoryInfoAssigned.isMeleeWeapon;
|
|
|
|
if (!isMeleeWeapon) {
|
|
if (showDebugPrint) {
|
|
print ("dragged fire weapon to unequip");
|
|
}
|
|
|
|
mainPlayerWeaponsManager.unequipWeapon (quickSlotFoundOnPress.Name, false, true);
|
|
}
|
|
|
|
if (isMeleeWeapon) {
|
|
if (showDebugPrint) {
|
|
print ("dragged melee Weapon to unequip");
|
|
}
|
|
|
|
mainMeleeWeaponsGrabbedManager.unEquipMeleeWeapon (quickSlotFoundOnPress.Name, false);
|
|
|
|
mainInventoryManager.unEquipObjectByName (quickSlotFoundOnPress.Name);
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("slot moved is object to use, like quest, or consumable, etc....");
|
|
}
|
|
|
|
if (quickSlotFoundOnPress.inventoryInfoAssigned.canBeEquiped) {
|
|
if (showDebugPrint) {
|
|
print ("dragged object to unequip");
|
|
}
|
|
|
|
mainInventoryManager.setCurrentInventoryObject (quickSlotFoundOnPress.inventoryInfoAssigned);
|
|
|
|
mainInventoryManager.unEquipCurrentObject ();
|
|
}
|
|
}
|
|
}
|
|
|
|
updateQuickAccessSlotInfo (-1, null, quickSlotFoundOnPress, null);
|
|
}
|
|
}
|
|
} else {
|
|
checkSlotInfoToRemove ();
|
|
}
|
|
|
|
resetDragAndDropSlotState ();
|
|
}
|
|
|
|
void checkSlotInfoToRemove ()
|
|
{
|
|
//The slot has been pressed on the quick access slots and dropped out
|
|
if (draggedFromQuickAccessSlots) {
|
|
//dragging a slot with two weapons assigned
|
|
if (quickSlotFoundOnPress.secondarySlotActive) {
|
|
string currentObjectName = quickSlotFoundOnPress.inventoryInfoAssigned.mainWeaponObjectInfo.getWeaponName ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("Dual weapon " + currentObjectName + " removed");
|
|
}
|
|
|
|
activatingDualWeaponSlot = true;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
currentRighWeaponName = currentObjectName;
|
|
currentLeftWeaponName = quickSlotFoundOnPress.secondElementName;
|
|
|
|
mainInventoryManager.setCurrentRighWeaponNameValue (currentRighWeaponName);
|
|
mainInventoryManager.setCurrentLeftWeaponNameValue (currentLeftWeaponName);
|
|
|
|
|
|
string weaponNameToUnequip = currentLeftWeaponName;
|
|
|
|
bool firstWeaponSharesPocket = checkIfWeaponSharesPocketInWeaponSlots (currentLeftWeaponName);
|
|
bool secondWeaponSharesPocket = false;
|
|
|
|
if (!firstWeaponSharesPocket) {
|
|
|
|
secondWeaponSharesPocket = checkIfWeaponSharesPocketInWeaponSlots (currentRighWeaponName);
|
|
|
|
if (secondWeaponSharesPocket) {
|
|
weaponNameToUnequip = currentRighWeaponName;
|
|
}
|
|
}
|
|
|
|
mainPlayerWeaponsManager.unequipWeapon (weaponNameToUnequip, activatingDualWeaponSlot, true);
|
|
|
|
if (secondWeaponSharesPocket) {
|
|
|
|
updateSingleWeaponSlotInfoWithoutAddingAnotherSlot (currentLeftWeaponName);
|
|
|
|
resetDragAndDropSlotState ();
|
|
|
|
return;
|
|
}
|
|
} else {
|
|
//dragging a slot with a single object assigned
|
|
if (quickSlotFoundOnPress.inventoryInfoAssigned.isWeapon) {
|
|
bool isMeleeWeapon = quickSlotFoundOnPress.inventoryInfoAssigned.isMeleeWeapon;
|
|
|
|
if (!isMeleeWeapon) {
|
|
if (showDebugPrint) {
|
|
print ("dragged fire weapon to unequip");
|
|
}
|
|
|
|
mainPlayerWeaponsManager.unequipWeapon (quickSlotFoundOnPress.Name, false, true);
|
|
}
|
|
|
|
if (isMeleeWeapon) {
|
|
mainMeleeWeaponsGrabbedManager.unEquipMeleeWeapon (quickSlotFoundOnPress.Name, false);
|
|
|
|
mainInventoryManager.unEquipObjectByName (quickSlotFoundOnPress.Name);
|
|
|
|
if (showDebugPrint) {
|
|
print ("dragged melee Weapon to unequip");
|
|
}
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("slot moved is object to use, like quest, or consumable, etc....");
|
|
}
|
|
|
|
if (quickSlotFoundOnPress.inventoryInfoAssigned.canBeEquiped) {
|
|
if (showDebugPrint) {
|
|
print ("dragged object to unequip " + quickSlotFoundOnPress.inventoryInfoAssigned.Name);
|
|
}
|
|
|
|
mainInventoryManager.setCurrentInventoryObject (quickSlotFoundOnPress.inventoryInfoAssigned);
|
|
|
|
mainInventoryManager.unEquipCurrentObject ();
|
|
}
|
|
}
|
|
}
|
|
|
|
updateQuickAccessSlotInfo (-1, null, quickSlotFoundOnPress, null);
|
|
}
|
|
}
|
|
|
|
public void updateQuickAccessInputKeysState (bool inventoryMenuOpened)
|
|
{
|
|
if (quickAccessInputNumberKeysEnabled) {
|
|
if (quickAccessInputNumberKeysPaused) {
|
|
return;
|
|
}
|
|
|
|
if (changeOfWeaponsInProccess) {
|
|
return;
|
|
}
|
|
|
|
int currentNumberInput = playerInput.checkNumberInput (numberQuickAccessSlots + 1);
|
|
|
|
if (currentNumberInput > -1) {
|
|
if (inventoryMenuOpened) {
|
|
if (assignQuickAccesssSlotsOnNumberKeysOnInventoryOpenedEnabled) {
|
|
inventoryInfo currentInventoryInfo = mainInventoryManager.getCurrentInventoryObjectInfo ();
|
|
|
|
if (currentInventoryInfo == null) {
|
|
return;
|
|
}
|
|
|
|
setOnQuickSlotsCurrentObjectDirectly (currentInventoryInfo, currentNumberInput);
|
|
}
|
|
} else {
|
|
selectingSlotByInputActive = true;
|
|
|
|
inputSetSlotByIndex (currentNumberInput);
|
|
|
|
selectingSlotByInputActive = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void inputSetSlotByIndex (int currentNumberInput)
|
|
{
|
|
if (!quickAccessInputNumberKeysEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (quickAccessInputNumberKeysPaused) {
|
|
return;
|
|
}
|
|
|
|
if (changeOfWeaponsInProccess) {
|
|
return;
|
|
}
|
|
|
|
if (currentNumberInput == 0) {
|
|
currentNumberInput = 9;
|
|
} else {
|
|
currentNumberInput--;
|
|
}
|
|
|
|
if (quickAccessSlotInfoListCount == 0) {
|
|
return;
|
|
}
|
|
|
|
if (currentNumberInput >= quickAccessSlotInfoListCount) {
|
|
return;
|
|
}
|
|
|
|
if (!canUseInput ()) {
|
|
return;
|
|
}
|
|
|
|
if (!canSelectSlot ()) {
|
|
return;
|
|
}
|
|
|
|
checkQuickAccessSlotToSelect (currentNumberInput);
|
|
}
|
|
|
|
public void setQuickAccessInputNumberKeysPausedState (bool state)
|
|
{
|
|
quickAccessInputNumberKeysPaused = state;
|
|
}
|
|
|
|
public void selectFirstMeleeWeaponAvailable ()
|
|
{
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
if (currentQuickAccessList [j].slotActive &&
|
|
currentQuickAccessList [j].inventoryInfoAssigned.isMeleeWeapon) {
|
|
|
|
checkQuickAccessSlotToSelect (j);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void selectFirstFireWeaponAvailable ()
|
|
{
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
if (currentQuickAccessList [j].slotActive &&
|
|
currentQuickAccessList [j].inventoryInfoAssigned.isWeapon &&
|
|
!currentQuickAccessList [j].inventoryInfoAssigned.isMeleeWeapon) {
|
|
|
|
checkQuickAccessSlotToSelect (j);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void selectFirstGeneralWeaponAvailable ()
|
|
{
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
if (currentQuickAccessList [j].slotActive &&
|
|
currentQuickAccessList [j].inventoryInfoAssigned.isWeapon) {
|
|
|
|
checkQuickAccessSlotToSelect (j);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool selectCurrentSlotWeaponIfAvailable ()
|
|
{
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
if (currentQuickAccessList [j].slotActive && currentSlotIndex == j &&
|
|
currentQuickAccessList [j].inventoryInfoAssigned.isWeapon) {
|
|
|
|
checkQuickAccessSlotToSelect (j);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void checkQuickAccessSlotToSelectByName (string objectOnSlotName)
|
|
{
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
if (currentQuickAccessList [j].slotActive) {
|
|
if (currentQuickAccessList [j].inventoryInfoAssigned.Name.Equals (objectOnSlotName)) {
|
|
checkQuickAccessSlotToSelect (j);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool canSelectSlot ()
|
|
{
|
|
if (mainPlayerWeaponsManager.isActionActiveInPlayer ()) {
|
|
if (showDebugPrint) {
|
|
print ("action active, cancelling quick access slot action");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (mainPlayerWeaponsManager.currentWeaponIsMoving ()) {
|
|
if (showDebugPrint) {
|
|
print ("weapons are moving, cancelling quick access slot action");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (mainPlayerWeaponsManager.weaponsAreMoving ()) {
|
|
if (showDebugPrint) {
|
|
print ("weapons are still moving, cancelling quick access slot action");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool changeToWeaponWithoutDoubleSelection;
|
|
|
|
public void setOverrideChangeToWeaponWithoutDoubleSelectionState (bool state)
|
|
{
|
|
changeToWeaponWithoutDoubleSelection = state;
|
|
}
|
|
|
|
void checkQuickAccessSlotToSelect (int quickAccessSlotIndex)
|
|
{
|
|
if (lastTimeQuickAccessSlotSelected != 0 && Time.time < minTimeToSelectQuickAccessSlot + lastTimeQuickAccessSlotSelected) {
|
|
if (showDebugPrint) {
|
|
print ("not enough time in between press to change to another quick access slot");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [quickAccessSlotIndex];
|
|
|
|
if (showDebugPrint) {
|
|
print ("Quick access number key pressed " + quickAccessSlotIndex + " with the object assigned " + currentSlotInfo.Name);
|
|
}
|
|
|
|
if (currentSlotInfo != null) {
|
|
if (currentSlotInfo.slotActive) {
|
|
inventoryInfo inventoryObjectInfo = currentSlotInfo.inventoryInfoAssigned;
|
|
|
|
if (inventoryObjectInfo.isWeapon || inventoryObjectInfo.isMeleeWeapon || inventoryObjectInfo.isMeleeShield) {
|
|
bool isMeleeWeapon = inventoryObjectInfo.isMeleeWeapon || inventoryObjectInfo.isMeleeShield;
|
|
|
|
if (mainInventoryManager.isUsingGenericModelActive ()) {
|
|
return;
|
|
}
|
|
|
|
if (mainMeleeWeaponsGrabbedManager.isCarryingRegularPhysicalObject ()) {
|
|
|
|
if (showDebugPrint) {
|
|
print ("character is carrying a physical regular object, cancelling check");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (mainMeleeWeaponsGrabbedManager.isMeleeWeaponsGrabbedManagerActive ()) {
|
|
if (mainMeleeWeaponsGrabbedManager.isCurrentWeaponThrown ()) {
|
|
bool checkIfReturnThrowWeaponOrDropItExternallyResult =
|
|
mainMeleeWeaponsGrabbedManager.checkIfReturnThrowWeaponOrDropItExternally ();
|
|
|
|
if (checkIfReturnThrowWeaponOrDropItExternallyResult) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!isMeleeWeapon) {
|
|
if (mainPlayerWeaponsManager.isWeaponsModeActive ()) {
|
|
bool selectWeaponResult = true;
|
|
|
|
if (selectingSlotByInputActive) {
|
|
if (holsterFireWeaponIfSlotAlreadySelected) {
|
|
if (canSelectSlot ()) {
|
|
if (mainPlayerWeaponsManager.isUsingWeapons ()) {
|
|
string weaponName = mainPlayerWeaponsManager.getCurrentWeaponName ();
|
|
|
|
if (inventoryObjectInfo.Name.Equals (weaponName)) {
|
|
mainPlayerWeaponsManager.drawOrKeepWeaponInput ();
|
|
|
|
selectWeaponResult = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (selectWeaponResult) {
|
|
bool changeToWeaponWithoutDoubleSelectionResult = false;
|
|
|
|
if (changeToWeaponWithoutDoubleSelection) {
|
|
changeToWeaponWithoutDoubleSelectionResult = true;
|
|
|
|
changeToWeaponWithoutDoubleSelection = false;
|
|
}
|
|
|
|
if (changeAlwaysToWeaponWithoutDoubleSelection) {
|
|
changeToWeaponWithoutDoubleSelectionResult = true;
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("check Weapon To Select On Quick Access Slots " + inventoryObjectInfo.Name + " " + changeToWeaponWithoutDoubleSelectionResult);
|
|
}
|
|
|
|
mainPlayerWeaponsManager.checkWeaponToSelectOnQuickAccessSlots (inventoryObjectInfo.Name, changeToWeaponWithoutDoubleSelectionResult);
|
|
}
|
|
|
|
lastTimeQuickAccessSlotSelected = Time.time;
|
|
} else {
|
|
changeFromMeleeToFireWeapons (inventoryObjectInfo.Name, quickAccessSlotIndex);
|
|
}
|
|
}
|
|
|
|
if (isMeleeWeapon) {
|
|
if (mainMeleeWeaponsGrabbedManager.isMeleeWeaponsGrabbedManagerActive ()) {
|
|
|
|
bool selectWeaponResult = true;
|
|
|
|
string weaponInventoryObjectName = inventoryObjectInfo.Name;
|
|
|
|
if (selectingSlotByInputActive) {
|
|
|
|
if (sheatheMeleeWeaponsIfSlotAlreadySelected) {
|
|
if (canSelectSlot ()) {
|
|
|
|
if (mainMeleeWeaponsGrabbedManager.characterIsCarryingWeapon ()) {
|
|
string weaponName = mainMeleeWeaponsGrabbedManager.getCurrentWeaponName ();
|
|
|
|
if (inventoryObjectInfo.isMeleeShield) {
|
|
weaponName = mainMeleeWeaponsGrabbedManager.getCurrentShieldName ();
|
|
}
|
|
|
|
if (inventoryObjectInfo.Name.Equals (weaponName) &&
|
|
mainMeleeWeaponsGrabbedManager.getLastTimeDrawMeleeWeapon () > 0.7f) {
|
|
mainMeleeWeaponsGrabbedManager.checkToKeepWeapon ();
|
|
|
|
selectWeaponResult = false;
|
|
}
|
|
} else {
|
|
if (inventoryObjectInfo.isMeleeShield) {
|
|
weaponInventoryObjectName = mainMeleeWeaponsGrabbedManager.getEmptyWeaponToUseOnlyShield ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (selectWeaponResult) {
|
|
mainMeleeWeaponsGrabbedManager.checkWeaponToSelectOnQuickAccessSlots (weaponInventoryObjectName);
|
|
}
|
|
|
|
showQuickAccessSlotsParentWhenSlotSelected (quickAccessSlotIndex + 1);
|
|
|
|
lastTimeQuickAccessSlotSelected = Time.time;
|
|
} else {
|
|
changeFromFireToMeleeWeapons (inventoryObjectInfo.Name, quickAccessSlotIndex);
|
|
}
|
|
}
|
|
} else {
|
|
lastTimeQuickAccessSlotSelected = Time.time;
|
|
|
|
if (inventoryObjectInfo.canBeEquiped) {
|
|
if (showDebugPrint) {
|
|
print ("object selected can be equipped");
|
|
}
|
|
|
|
mainInventoryManager.useEquippedObjectAction (inventoryObjectInfo.Name, inventoryObjectInfo);
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("object selected is regular inventory object");
|
|
}
|
|
|
|
mainInventoryManager.setCurrentInventoryObject (inventoryObjectInfo);
|
|
|
|
mainInventoryManager.setUsingCurrentObjectFromQuickAccessSlotsInventoryState (true);
|
|
|
|
mainInventoryManager.useCurrentObject ();
|
|
|
|
mainInventoryManager.setUsingCurrentObjectFromQuickAccessSlotsInventoryState (false);
|
|
|
|
if (showDebugPrint) {
|
|
print (inventoryObjectInfo.amount);
|
|
}
|
|
|
|
if (inventoryObjectInfo.amount <= 0) {
|
|
if (showDebugPrint) {
|
|
print ("object used " + inventoryObjectInfo.Name + " without amount remaining, removing from quick access slots");
|
|
}
|
|
|
|
updateQuickAccessSlotInfo (-1, null, currentSlotInfo, null);
|
|
} else {
|
|
updateQuickAccesSlotAmount (quickAccessSlotIndex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Coroutine changeBetweenWeaponsCoroutine;
|
|
|
|
public void changeFromMeleeToFireWeapons (string weaponName, int quickAccessSlotIndex)
|
|
{
|
|
stopChangeOfWeaponsCoroutine ();
|
|
|
|
changeBetweenWeaponsCoroutine = StartCoroutine (changeOfWeaponsCoroutine (true, weaponName, quickAccessSlotIndex));
|
|
}
|
|
|
|
public void changeFromFireToMeleeWeapons (string weaponName, int quickAccessSlotIndex)
|
|
{
|
|
stopChangeOfWeaponsCoroutine ();
|
|
|
|
changeBetweenWeaponsCoroutine = StartCoroutine (changeOfWeaponsCoroutine (false, weaponName, quickAccessSlotIndex));
|
|
}
|
|
|
|
public void stopChangeOfWeaponsCoroutine ()
|
|
{
|
|
if (changeBetweenWeaponsCoroutine != null) {
|
|
StopCoroutine (changeBetweenWeaponsCoroutine);
|
|
}
|
|
|
|
changeOfWeaponsInProccess = false;
|
|
}
|
|
|
|
IEnumerator changeOfWeaponsCoroutine (bool changingFromMeleeToFireWeapons, string weaponName, int quickAccessSlotIndex)
|
|
{
|
|
changeOfWeaponsInProccess = true;
|
|
|
|
bool weaponHolstered = false;
|
|
|
|
bool checkWeaponChange = true;
|
|
|
|
if (changingFromMeleeToFireWeapons) {
|
|
if (showDebugPrint) {
|
|
print ("changing from melee to fire weapons");
|
|
}
|
|
|
|
if (mainMeleeWeaponsGrabbedManager.characterIsCarryingWeapon ()) {
|
|
mainMeleeWeaponsGrabbedManager.drawOrKeepMeleeWeaponWithoutCheckingInputActive ();
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("changing from fire to melee weapons");
|
|
}
|
|
|
|
if (mainPlayerWeaponsManager.isPlayerCarringWeapon ()) {
|
|
mainPlayerWeaponsManager.checkIfKeepSingleOrDualWeapon ();
|
|
}
|
|
}
|
|
|
|
if (checkWeaponChange) {
|
|
yield return new WaitForSeconds (0.1f);
|
|
|
|
float lastTimeChangeActive = Time.time;
|
|
|
|
while (!weaponHolstered) {
|
|
if (changingFromMeleeToFireWeapons) {
|
|
if (!mainMeleeWeaponsGrabbedManager.characterIsCarryingWeapon ()) {
|
|
weaponHolstered = true;
|
|
}
|
|
} else {
|
|
if (mainPlayerWeaponsManager.checkPlayerIsNotCarringWeapons ()) {
|
|
weaponHolstered = true;
|
|
}
|
|
}
|
|
|
|
if (mainPlayerWeaponsManager.isActionActiveInPlayer ()) {
|
|
weaponHolstered = false;
|
|
}
|
|
|
|
if (Time.time > lastTimeChangeActive + 4) {
|
|
if (showDebugPrint) {
|
|
print ("Check time too long for quick access slots, cancelling");
|
|
}
|
|
|
|
weaponHolstered = true;
|
|
}
|
|
|
|
yield return null;
|
|
}
|
|
|
|
if (changingFromMeleeToFireWeapons) {
|
|
eventToSetFireWeaponsMode.Invoke ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("object selected is fire weapon");
|
|
}
|
|
|
|
mainPlayerWeaponsManager.checkWeaponToSelectOnQuickAccessSlots (weaponName, true);
|
|
} else {
|
|
eventToSetMeleeWeaponsMode.Invoke ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("object selected is melee weapon");
|
|
}
|
|
|
|
mainMeleeWeaponsGrabbedManager.checkWeaponToSelectOnQuickAccessSlots (weaponName);
|
|
|
|
showQuickAccessSlotsParentWhenSlotSelected (quickAccessSlotIndex + 1);
|
|
}
|
|
}
|
|
|
|
yield return null;
|
|
|
|
lastTimeQuickAccessSlotSelected = Time.time;
|
|
|
|
changeOfWeaponsInProccess = false;
|
|
}
|
|
|
|
public void changeToMeleeWeapons (string meleeWeaponName)
|
|
{
|
|
stopChangeOfWeaponsCoroutine ();
|
|
|
|
int quickAccessSlotIndex = currentQuickAccessList.FindIndex (s => s.Name == meleeWeaponName);
|
|
|
|
if (quickAccessSlotIndex > -1) {
|
|
changeBetweenWeaponsCoroutine = StartCoroutine (changeToMeleeWeaponsCoroutine (meleeWeaponName, quickAccessSlotIndex));
|
|
}
|
|
}
|
|
|
|
IEnumerator changeToMeleeWeaponsCoroutine (string weaponName, int quickAccessSlotIndex)
|
|
{
|
|
changeOfWeaponsInProccess = true;
|
|
|
|
bool weaponHolstered = false;
|
|
|
|
bool checkWeaponChange = true;
|
|
|
|
if (showDebugPrint) {
|
|
print ("changing from fire to melee weapons");
|
|
}
|
|
|
|
if (mainPlayerWeaponsManager.isPlayerCarringWeapon ()) {
|
|
mainPlayerWeaponsManager.checkIfKeepSingleOrDualWeapon ();
|
|
}
|
|
|
|
if (checkWeaponChange) {
|
|
yield return new WaitForSeconds (0.1f);
|
|
|
|
float lastTimeChangeActive = Time.time;
|
|
|
|
while (!weaponHolstered) {
|
|
if (mainPlayerWeaponsManager.checkPlayerIsNotCarringWeapons ()) {
|
|
weaponHolstered = true;
|
|
}
|
|
|
|
if (mainPlayerWeaponsManager.isActionActiveInPlayer ()) {
|
|
weaponHolstered = false;
|
|
}
|
|
|
|
if (Time.time > lastTimeChangeActive + 4) {
|
|
if (showDebugPrint) {
|
|
print ("Check time too long for quick access slots, cancelling");
|
|
}
|
|
|
|
weaponHolstered = true;
|
|
}
|
|
|
|
yield return null;
|
|
}
|
|
|
|
eventToSetMeleeWeaponsMode.Invoke ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("object selected is melee weapon");
|
|
}
|
|
|
|
mainMeleeWeaponsGrabbedManager.checkWeaponToSelectOnQuickAccessSlots (weaponName);
|
|
|
|
showQuickAccessSlotsParentWhenSlotSelected (quickAccessSlotIndex + 1);
|
|
}
|
|
|
|
yield return null;
|
|
|
|
lastTimeQuickAccessSlotSelected = Time.time;
|
|
|
|
changeOfWeaponsInProccess = false;
|
|
}
|
|
|
|
//START INPUT FUNCTIONS
|
|
public void inputSelectNextOrPreviousQuickAccessSlot (bool state)
|
|
{
|
|
if (!canUseInput ()) {
|
|
return;
|
|
}
|
|
|
|
if (!canSelectSlot ()) {
|
|
return;
|
|
}
|
|
|
|
if (!useInventoryQuickAccessSlots) {
|
|
return;
|
|
}
|
|
|
|
if (!changeWeaponsWithKeysActive) {
|
|
return;
|
|
}
|
|
|
|
if (useEventsOnChangeWeaponsWithKeysActive) {
|
|
eventsOnChangeWeaponsWithKeysActive.Invoke (state);
|
|
|
|
return;
|
|
}
|
|
|
|
int nextSlotIndex = currentSlotIndex;
|
|
|
|
if (state) {
|
|
nextSlotIndex++;
|
|
|
|
if (nextSlotIndex > numberQuickAccessSlots - 1) {
|
|
nextSlotIndex = 0;
|
|
}
|
|
} else {
|
|
nextSlotIndex--;
|
|
|
|
if (nextSlotIndex < 0) {
|
|
nextSlotIndex = numberQuickAccessSlots - 1;
|
|
}
|
|
}
|
|
|
|
bool exit = false;
|
|
|
|
int loop = 0;
|
|
|
|
while (!exit) {
|
|
for (int k = 0; k < quickAccessSlotInfoListCount; k++) {
|
|
if (currentQuickAccessList [k].slotActive && k == nextSlotIndex) {
|
|
exit = true;
|
|
}
|
|
}
|
|
|
|
loop++;
|
|
|
|
if (loop > 100) {
|
|
exit = true;
|
|
}
|
|
|
|
if (!exit) {
|
|
if (state) {
|
|
//get the current index
|
|
nextSlotIndex++;
|
|
|
|
if (nextSlotIndex > numberQuickAccessSlots - 1) {
|
|
nextSlotIndex = 0;
|
|
}
|
|
} else {
|
|
nextSlotIndex--;
|
|
|
|
if (nextSlotIndex < 0) {
|
|
nextSlotIndex = numberQuickAccessSlots - 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
checkQuickAccessSlotToSelect (nextSlotIndex);
|
|
}
|
|
|
|
public void inputNextOrPreviousQuickAccessSlotByMouseWheel (bool state)
|
|
{
|
|
if (!quickAccessInputMouseWheelActive) {
|
|
return;
|
|
}
|
|
|
|
inputSelectNextOrPreviousQuickAccessSlot (state);
|
|
}
|
|
|
|
public bool checkIfWeaponSharesPocketInWeaponSlots (string weaponName)
|
|
{
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [i];
|
|
|
|
if (currentSlotInfo.slotActive &&
|
|
!currentSlotInfo.secondarySlotActive &&
|
|
currentSlotInfo.inventoryInfoAssigned.isWeapon &&
|
|
!currentSlotInfo.inventoryInfoAssigned.isMeleeWeapon) {
|
|
|
|
string currentObjectName = currentSlotInfo.inventoryInfoAssigned.mainWeaponObjectInfo.getWeaponName ();
|
|
|
|
if (showDebugPrint) {
|
|
print (weaponName + " " + currentObjectName);
|
|
}
|
|
|
|
if (mainPlayerWeaponsManager.checkIfWeaponIsOnSamePocket (weaponName, currentObjectName)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void updateSingleWeaponSlotInfo (string currentRighWeaponName, string currentLeftWeaponName)
|
|
{
|
|
playerWeaponSystem currentRightWeaponSystem = mainPlayerWeaponsManager.getWeaponSystemByName (currentRighWeaponName);
|
|
playerWeaponSystem currentLeftWeaponSystem = mainPlayerWeaponsManager.getWeaponSystemByName (currentLeftWeaponName);
|
|
|
|
int currentSlotToDualWeaponsIndex = currentRightWeaponSystem.getWeaponNumberKey () - 1;
|
|
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotToDualWeapons = currentQuickAccessList [currentSlotToDualWeaponsIndex];
|
|
|
|
activatingDualWeaponSlot = false;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
updateQuickAccessSlotInfo (currentSlotToDualWeaponsIndex, currentSlotToDualWeapons.inventoryInfoAssigned, null, null);
|
|
|
|
//get the amount of free slots
|
|
int firstFreeWeaponSlotIndex = -1;
|
|
|
|
int numberOfFreeSlots = 0;
|
|
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
if (!currentQuickAccessList [i].slotActive) {
|
|
numberOfFreeSlots++;
|
|
}
|
|
}
|
|
|
|
if (numberOfFreeSlots > 0) {
|
|
firstFreeWeaponSlotIndex = -1;
|
|
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
if (!currentQuickAccessList [i].slotActive) {
|
|
if (firstFreeWeaponSlotIndex == -1) {
|
|
firstFreeWeaponSlotIndex = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
inventoryList = mainInventoryManager.inventoryList;
|
|
|
|
int inventoryListCount = inventoryList.Count;
|
|
|
|
for (int i = 0; i < inventoryListCount; i++) {
|
|
inventoryInfo currentInventoryInfo = inventoryList [i];
|
|
|
|
if (currentInventoryInfo.isWeapon && !currentInventoryInfo.isMeleeWeapon) {
|
|
if (currentInventoryInfo.Name.Equals (currentLeftWeaponSystem.getWeaponSystemName ())) {
|
|
currentSlotToMoveInventoryObject = currentInventoryInfo;
|
|
}
|
|
}
|
|
}
|
|
|
|
updateQuickAccessSlotInfo (firstFreeWeaponSlotIndex, currentSlotToMoveInventoryObject, null, null);
|
|
} else {
|
|
mainPlayerWeaponsManager.unequipWeapon (currentLeftWeaponSystem.getWeaponSystemName (), false, true);
|
|
}
|
|
}
|
|
|
|
public void updateSingleWeaponSlotInfoWithoutAddingAnotherSlot (string currentRighWeaponName)
|
|
{
|
|
int rightWeaponSlotIndex = -1;
|
|
|
|
playerWeaponSystem currentRightWeaponSystem = mainPlayerWeaponsManager.getWeaponSystemByName (currentRighWeaponName);
|
|
|
|
int currentSlotToDualWeaponsIndex = currentRightWeaponSystem.getWeaponNumberKey () - 1;
|
|
|
|
inventoryList = mainInventoryManager.inventoryList;
|
|
|
|
int inventoryListCount = inventoryList.Count;
|
|
|
|
for (int i = 0; i < inventoryListCount; i++) {
|
|
inventoryInfo currentInventoryInfo = inventoryList [i];
|
|
|
|
if (currentInventoryInfo.isWeapon && !currentInventoryInfo.isMeleeWeapon) {
|
|
if (currentInventoryInfo.Name.Equals (currentRighWeaponName)) {
|
|
currentSlotToMoveInventoryObject = currentInventoryInfo;
|
|
}
|
|
}
|
|
}
|
|
|
|
activatingDualWeaponSlot = false;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
if (showDebugPrint) {
|
|
print ("set single slot for weapon " + currentRighWeaponName + " on slot " + rightWeaponSlotIndex);
|
|
}
|
|
|
|
updateQuickAccessSlotInfo (currentSlotToDualWeaponsIndex, currentSlotToMoveInventoryObject, null, null);
|
|
}
|
|
|
|
public void updateDualWeaponSlotInfo (string currentRighWeaponName, string currentLeftWeaponName)
|
|
{
|
|
int rightWeaponSlotIndex = -1;
|
|
int leftWeaponSlotIndex = -1;
|
|
|
|
playerWeaponSystem currentRightWeaponSystem = mainPlayerWeaponsManager.getWeaponSystemByName (currentRighWeaponName);
|
|
playerWeaponSystem currentLeftWeaponSystem = mainPlayerWeaponsManager.getWeaponSystemByName (currentLeftWeaponName);
|
|
|
|
int currentSlotToDualWeaponsIndex = currentRightWeaponSystem.getWeaponNumberKey () - 1;
|
|
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotToDualWeapons = currentQuickAccessList [currentSlotToDualWeaponsIndex];
|
|
|
|
playerWeaponSystem rightWeaponSystemToSetToSingle = mainPlayerWeaponsManager.getWeaponSystemByName (currentSlotToDualWeapons.firstElementName);
|
|
|
|
playerWeaponSystem leftWeaponSystemToSetToSingle = mainPlayerWeaponsManager.getWeaponSystemByName (currentSlotToDualWeapons.secondElementName);
|
|
|
|
bool rightWeaponIsDualOnOtherSlot = false;
|
|
bool leftWeaponIsDualOnOtherSlot = false;
|
|
|
|
bool rightWeaponIsMainWeaponOnCurrentSlotToDualWeapon = false;
|
|
bool leftWeaponIsMainWepaonOnCurrentSLotToDualWeapon = false;
|
|
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [i];
|
|
|
|
if (currentSlotToDualWeaponsIndex != i) {
|
|
//search the right weapon slot of the new right weapon
|
|
if (currentSlotInfo.Name.Equals (currentRighWeaponName)) {
|
|
rightWeaponSlotIndex = i;
|
|
}
|
|
|
|
if (currentSlotInfo.firstElementName.Equals (currentRighWeaponName)) {
|
|
rightWeaponSlotIndex = i;
|
|
|
|
rightWeaponIsDualOnOtherSlot = true;
|
|
rightWeaponIsMainWeaponOnCurrentSlotToDualWeapon = true;
|
|
}
|
|
|
|
if (currentSlotInfo.secondElementName.Equals (currentRighWeaponName)) {
|
|
rightWeaponSlotIndex = i;
|
|
|
|
rightWeaponIsDualOnOtherSlot = true;
|
|
}
|
|
|
|
//search the left weapon slot of the new left weapon
|
|
if (currentSlotInfo.Name.Equals (currentLeftWeaponName)) {
|
|
leftWeaponSlotIndex = i;
|
|
}
|
|
|
|
if (currentSlotInfo.firstElementName.Equals (currentLeftWeaponName)) {
|
|
leftWeaponSlotIndex = i;
|
|
|
|
leftWeaponIsDualOnOtherSlot = true;
|
|
leftWeaponIsMainWepaonOnCurrentSLotToDualWeapon = true;
|
|
}
|
|
|
|
if (currentSlotInfo.secondElementName.Equals (currentLeftWeaponName)) {
|
|
leftWeaponSlotIndex = i;
|
|
|
|
leftWeaponIsDualOnOtherSlot = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
int inventoryListCount = inventoryList.Count;
|
|
|
|
//remove or add a new slot for the right weapon according to if it was configured as a single weapon in its own slot or dual weapon in a dual slot
|
|
if (rightWeaponSlotIndex != -1) {
|
|
if (rightWeaponIsDualOnOtherSlot) {
|
|
if (showDebugPrint) {
|
|
print ("right weapon is dual on other slot");
|
|
}
|
|
|
|
if (rightWeaponIsMainWeaponOnCurrentSlotToDualWeapon) {
|
|
if (showDebugPrint) {
|
|
print ("right weapon is main weapon on other slot");
|
|
}
|
|
|
|
//in this case, leave the other weapon from this slot as the main weapon for this slot and remove the current right one from it
|
|
string secondaryWeaponNameOnSlot = currentQuickAccessList [rightWeaponSlotIndex].secondElementName;
|
|
|
|
inventoryList = mainInventoryManager.inventoryList;
|
|
|
|
inventoryListCount = inventoryList.Count;
|
|
|
|
for (int i = 0; i < inventoryListCount; i++) {
|
|
inventoryInfo currentInventoryInfo = inventoryList [i];
|
|
|
|
if (currentInventoryInfo.isWeapon && !currentInventoryInfo.isMeleeWeapon) {
|
|
if (currentInventoryInfo.Name.Equals (secondaryWeaponNameOnSlot)) {
|
|
currentSlotToMoveInventoryObject = currentInventoryInfo;
|
|
}
|
|
}
|
|
}
|
|
|
|
activatingDualWeaponSlot = false;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
updateQuickAccessSlotInfo (rightWeaponSlotIndex, currentSlotToMoveInventoryObject, null, null);
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("right weapon is secondary weapon on other slot");
|
|
}
|
|
|
|
activatingDualWeaponSlot = false;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
updateQuickAccessSlotInfo (rightWeaponSlotIndex, currentQuickAccessList [rightWeaponSlotIndex].inventoryInfoAssigned, null, null);
|
|
}
|
|
} else {
|
|
updateQuickAccessSlotInfo (-1, null, currentQuickAccessList [rightWeaponSlotIndex], null);
|
|
}
|
|
}
|
|
|
|
inventoryListCount = inventoryList.Count;
|
|
|
|
//remove or add a new slot for the left weapon according to if it was configured as a single weapon in its own slot or dual weapon in a dual slot
|
|
if (leftWeaponSlotIndex != -1) {
|
|
if (leftWeaponIsDualOnOtherSlot) {
|
|
if (showDebugPrint) {
|
|
print ("left weapon is dual on other slot");
|
|
}
|
|
|
|
if (leftWeaponIsMainWepaonOnCurrentSLotToDualWeapon) {
|
|
if (showDebugPrint) {
|
|
print ("left weapon is main weapon on other slot");
|
|
}
|
|
|
|
//in this case, leave the other weapon from this slot as the main weapon for this slot and remove the current left one from it
|
|
string secondaryWeaponNameOnSlot = currentQuickAccessList [leftWeaponSlotIndex].secondElementName;
|
|
|
|
inventoryList = mainInventoryManager.inventoryList;
|
|
|
|
for (int i = 0; i < inventoryListCount; i++) {
|
|
inventoryInfo currentInventoryInfo = inventoryList [i];
|
|
|
|
if (currentInventoryInfo.isWeapon && !currentInventoryInfo.isMeleeWeapon) {
|
|
if (currentInventoryInfo.Name.Equals (secondaryWeaponNameOnSlot)) {
|
|
currentSlotToMoveInventoryObject = currentInventoryInfo;
|
|
}
|
|
}
|
|
}
|
|
|
|
activatingDualWeaponSlot = false;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
updateQuickAccessSlotInfo (leftWeaponSlotIndex, currentSlotToMoveInventoryObject, null, null);
|
|
} else {
|
|
if (showDebugPrint) {
|
|
//in this case, the left weapon is configured as a secondary weapon in another slot, so set that slot as single again, removing the current left weapon from that slot
|
|
print ("left weapon is secondary weapon on other slot");
|
|
}
|
|
|
|
activatingDualWeaponSlot = false;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
updateQuickAccessSlotInfo (leftWeaponSlotIndex, currentQuickAccessList [leftWeaponSlotIndex].inventoryInfoAssigned, null, null);
|
|
}
|
|
} else {
|
|
updateQuickAccessSlotInfo (-1, null, currentQuickAccessList [leftWeaponSlotIndex], null);
|
|
}
|
|
}
|
|
|
|
inventoryList = mainInventoryManager.inventoryList;
|
|
|
|
inventoryListCount = inventoryList.Count;
|
|
|
|
// configure the two selected weapons in the same slot
|
|
for (int i = 0; i < inventoryListCount; i++) {
|
|
inventoryInfo currentInventoryInfo = inventoryList [i];
|
|
|
|
if (currentInventoryInfo.isWeapon && !currentInventoryInfo.isMeleeWeapon) {
|
|
if (currentInventoryInfo.Name.Equals (currentRighWeaponName)) {
|
|
currentSlotToMoveInventoryObject = currentInventoryInfo;
|
|
}
|
|
}
|
|
}
|
|
|
|
activatingDualWeaponSlot = true;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
if (showDebugPrint) {
|
|
print (currentRightWeaponSystem.getWeaponSystemName () + " configured as right weapon and " + currentLeftWeaponSystem.getWeaponSystemName () + " configured as left weapon");
|
|
}
|
|
|
|
updateQuickAccessSlotInfo (currentSlotToDualWeaponsIndex, currentSlotToMoveInventoryObject, null, currentLeftWeaponSystem);
|
|
|
|
activatingDualWeaponSlot = false;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
|
|
//get the amount of free slots
|
|
int firstFreeWeaponSlotIndex = -1;
|
|
|
|
int numberOfFreeSlots = 0;
|
|
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
if (!currentQuickAccessList [i].slotActive) {
|
|
numberOfFreeSlots++;
|
|
}
|
|
}
|
|
|
|
inventoryListCount = inventoryList.Count;
|
|
|
|
//get the original weapons assigned in the current slot which is used for other couple of weapons
|
|
//if the number of slots available is higher than 1, both weapons can be placed as new slots if there is right and left weapon to assign
|
|
|
|
if (numberOfFreeSlots > 1 ||
|
|
(rightWeaponSystemToSetToSingle != null && leftWeaponSystemToSetToSingle == null) ||
|
|
(rightWeaponSystemToSetToSingle == null && leftWeaponSystemToSetToSingle != null)) {
|
|
|
|
//assign the first free slot to the right weapon
|
|
if (numberOfFreeSlots > 1 || (rightWeaponSystemToSetToSingle != null && leftWeaponSystemToSetToSingle == null)) {
|
|
if (rightWeaponSystemToSetToSingle != null) {
|
|
|
|
firstFreeWeaponSlotIndex = -1;
|
|
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
if (!currentQuickAccessList [i].slotActive) {
|
|
if (firstFreeWeaponSlotIndex == -1) {
|
|
firstFreeWeaponSlotIndex = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
string temporalRightWeaponName = rightWeaponSystemToSetToSingle.getWeaponSystemName ();
|
|
|
|
if (!temporalRightWeaponName.Equals (currentRighWeaponName) && !temporalRightWeaponName.Equals (currentLeftWeaponName)) {
|
|
|
|
inventoryList = mainInventoryManager.inventoryList;
|
|
|
|
inventoryListCount = inventoryList.Count;
|
|
|
|
for (int i = 0; i < inventoryListCount; i++) {
|
|
inventoryInfo currentInventoryInfo = inventoryList [i];
|
|
|
|
if (currentInventoryInfo.isWeapon && !currentInventoryInfo.isMeleeWeapon) {
|
|
if (currentInventoryInfo.Name.Equals (temporalRightWeaponName)) {
|
|
currentSlotToMoveInventoryObject = currentInventoryInfo;
|
|
}
|
|
}
|
|
}
|
|
|
|
updateQuickAccessSlotInfo (firstFreeWeaponSlotIndex, currentSlotToMoveInventoryObject, null, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
//assign the first free slot to the left weapon
|
|
if (numberOfFreeSlots > 1 || (rightWeaponSystemToSetToSingle == null && leftWeaponSystemToSetToSingle != null)) {
|
|
if (leftWeaponSystemToSetToSingle != null) {
|
|
|
|
firstFreeWeaponSlotIndex = -1;
|
|
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
if (!currentQuickAccessList [i].slotActive) {
|
|
if (firstFreeWeaponSlotIndex == -1) {
|
|
firstFreeWeaponSlotIndex = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
string temporalLeftWeaponName = leftWeaponSystemToSetToSingle.getWeaponSystemName ();
|
|
|
|
if (!temporalLeftWeaponName.Equals (currentRighWeaponName) && !temporalLeftWeaponName.Equals (currentLeftWeaponName)) {
|
|
|
|
inventoryList = mainInventoryManager.inventoryList;
|
|
|
|
inventoryListCount = inventoryList.Count;
|
|
|
|
for (int i = 0; i < inventoryListCount; i++) {
|
|
inventoryInfo currentInventoryInfo = inventoryList [i];
|
|
|
|
if (currentInventoryInfo.isWeapon && !currentInventoryInfo.isMeleeWeapon) {
|
|
if (currentInventoryInfo.Name.Equals (temporalLeftWeaponName)) {
|
|
currentSlotToMoveInventoryObject = currentInventoryInfo;
|
|
}
|
|
}
|
|
}
|
|
|
|
updateQuickAccessSlotInfo (firstFreeWeaponSlotIndex, currentSlotToMoveInventoryObject, null, null);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (rightWeaponSystemToSetToSingle == null && leftWeaponSystemToSetToSingle == null) {
|
|
//NO WEAPONS FOUND, USING LONG COMBINE ACTION
|
|
|
|
if (numberOfFreeSlots == 1) {
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
//else, the number of free slot is only 1, so both weapons need to be combined
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
if (!currentQuickAccessList [i].slotActive) {
|
|
if (firstFreeWeaponSlotIndex == -1) {
|
|
firstFreeWeaponSlotIndex = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (firstFreeWeaponSlotIndex != -1) {
|
|
activatingDualWeaponSlot = true;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
inventoryList = mainInventoryManager.inventoryList;
|
|
|
|
inventoryListCount = inventoryList.Count;
|
|
|
|
string temporalRightWeaponName = rightWeaponSystemToSetToSingle.getWeaponSystemName ();
|
|
|
|
for (int i = 0; i < inventoryList.Count; i++) {
|
|
inventoryInfo currentInventoryInfo = inventoryList [i];
|
|
|
|
if (currentInventoryInfo.isWeapon && !currentInventoryInfo.isMeleeWeapon) {
|
|
|
|
if (currentInventoryInfo.Name.Equals (temporalRightWeaponName)) {
|
|
currentSlotToMoveInventoryObject = currentInventoryInfo;
|
|
}
|
|
}
|
|
}
|
|
|
|
updateQuickAccessSlotInfo (firstFreeWeaponSlotIndex, currentSlotToMoveInventoryObject, null, leftWeaponSystemToSetToSingle);
|
|
|
|
activatingDualWeaponSlot = false;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void updateQuickAccessSlotInfo (int slotIndex, inventoryInfo currentSlotToMove, inventoryQuickAccessSlotElement.quickAccessSlotInfo slotToUnEquip, playerWeaponSystem secondaryWeaponToEquip)
|
|
{
|
|
bool slotFound = false;
|
|
|
|
if (slotIndex > -1 && slotIndex < quickAccessSlotInfoListCount && currentSlotToMove != null) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [slotIndex];
|
|
|
|
if (showDebugPrint) {
|
|
print ("updateQuickAccessSlotInfo for inventory object " + currentSlotToMove.Name);
|
|
}
|
|
|
|
if (currentSlotInfo != null) {
|
|
currentSlotInfo.Name = currentSlotToMove.Name;
|
|
currentSlotInfo.slotActive = true;
|
|
|
|
playerWeaponSystem currentPlayerWeaponSystem = null;
|
|
|
|
bool isMeleeWeapon = currentSlotToMove.isMeleeWeapon;
|
|
bool isWeapon = currentSlotToMove.isWeapon;
|
|
|
|
if (currentSlotToMove.isWeapon && !isMeleeWeapon) {
|
|
currentPlayerWeaponSystem = mainPlayerWeaponsManager.getWeaponSystemByName (currentSlotToMove.mainWeaponObjectInfo.getWeaponName ());
|
|
}
|
|
|
|
currentSlotInfo.secondarySlotActive = activatingDualWeaponSlot;
|
|
|
|
if (activatingDualWeaponSlot) {
|
|
currentSlotInfo.amountText.text = "";
|
|
|
|
currentSlotInfo.rightSecondarySlotIcon.texture = currentPlayerWeaponSystem.getWeaponInventorySlotIcon ();
|
|
currentSlotInfo.leftSecondarySlotIcon.texture = secondaryWeaponToEquip.getWeaponInventorySlotIcon ();
|
|
|
|
currentSlotInfo.firstElementName = currentPlayerWeaponSystem.getWeaponSystemName ();
|
|
currentSlotInfo.secondElementName = secondaryWeaponToEquip.getWeaponSystemName ();
|
|
} else {
|
|
if (isWeapon) {
|
|
if (!isMeleeWeapon) {
|
|
currentSlotInfo.amountText.text = currentPlayerWeaponSystem.getCurrentAmmoText ();
|
|
|
|
currentSlotInfo.slotIcon.texture = currentPlayerWeaponSystem.getWeaponInventorySlotIcon ();
|
|
}
|
|
|
|
if (isMeleeWeapon) {
|
|
currentSlotInfo.amountText.text = "";
|
|
|
|
currentSlotInfo.slotIcon.texture = currentSlotToMove.icon;
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("updating inventory object slot, like quest, or consumable, etc....");
|
|
}
|
|
|
|
if (currentSlotToMove.infiniteAmount) {
|
|
currentSlotInfo.amountText.text = "Inf";
|
|
} else {
|
|
currentSlotInfo.amountText.text = currentSlotToMove.amount.ToString ();
|
|
}
|
|
|
|
currentSlotInfo.slotIcon.texture = currentSlotToMove.icon;
|
|
}
|
|
|
|
currentSlotInfo.firstElementName = "";
|
|
currentSlotInfo.secondElementName = "";
|
|
}
|
|
|
|
bool amountTextContentActive = false;
|
|
|
|
if (isWeapon) {
|
|
if (!isMeleeWeapon) {
|
|
amountTextContentActive = currentPlayerWeaponSystem.weaponSettings.weaponUsesAmmo;
|
|
}
|
|
|
|
if (isMeleeWeapon) {
|
|
amountTextContentActive = false;
|
|
}
|
|
} else {
|
|
if (currentSlotToMove.isArmorClothAccessory) {
|
|
amountTextContentActive = false;
|
|
} else {
|
|
amountTextContentActive = true;
|
|
}
|
|
}
|
|
|
|
if (showSlotAmountEnabled) {
|
|
if (!showSlotAmmoAmountEnabled) {
|
|
if (currentSlotToMove.isWeapon && !currentSlotToMove.isMeleeWeapon) {
|
|
amountTextContentActive = false;
|
|
}
|
|
}
|
|
} else {
|
|
amountTextContentActive = false;
|
|
}
|
|
|
|
if (currentSlotInfo.amountTextContent.activeSelf != amountTextContentActive) {
|
|
currentSlotInfo.amountTextContent.SetActive (amountTextContentActive);
|
|
}
|
|
|
|
if (currentSlotInfo.slotMainSingleContent.activeSelf != !activatingDualWeaponSlot) {
|
|
currentSlotInfo.slotMainSingleContent.SetActive (!activatingDualWeaponSlot);
|
|
}
|
|
|
|
if (currentSlotInfo.slotMainDualContent.activeSelf != activatingDualWeaponSlot) {
|
|
currentSlotInfo.slotMainDualContent.SetActive (activatingDualWeaponSlot);
|
|
}
|
|
|
|
currentSlotInfo.inventoryInfoAssigned = currentSlotToMove;
|
|
|
|
int newNumberKey = slotIndex + 1;
|
|
|
|
if (newNumberKey > 9) {
|
|
newNumberKey = 0;
|
|
}
|
|
|
|
if (isWeapon) {
|
|
if (!isMeleeWeapon) {
|
|
currentPlayerWeaponSystem.setNumberKey (newNumberKey);
|
|
}
|
|
}
|
|
|
|
if (activatingDualWeaponSlot) {
|
|
secondaryWeaponToEquip.setNumberKey (newNumberKey);
|
|
}
|
|
|
|
currentSlotToMove.quickAccessSlotIndex = slotIndex;
|
|
|
|
slotFound = true;
|
|
|
|
if (hideEmptySlots && !inventoryOpened) {
|
|
if (!currentSlotInfo.slot.activeSelf) {
|
|
currentSlotInfo.slot.SetActive (true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!slotFound && slotToUnEquip != null) {
|
|
if (activatingDualWeaponSlot) {
|
|
playerWeaponSystem currentPlayerWeaponSystem = mainPlayerWeaponsManager.getWeaponSystemByName (slotToUnEquip.inventoryInfoAssigned.mainWeaponObjectInfo.getWeaponName ());
|
|
|
|
slotToUnEquip.amountText.text = currentPlayerWeaponSystem.getCurrentAmmoText ();
|
|
|
|
slotToUnEquip.slotIcon.texture = currentPlayerWeaponSystem.getWeaponInventorySlotIcon ();
|
|
|
|
if (!slotToUnEquip.slotMainSingleContent.activeSelf) {
|
|
slotToUnEquip.slotMainSingleContent.SetActive (true);
|
|
}
|
|
|
|
if (slotToUnEquip.slotMainDualContent.activeSelf) {
|
|
slotToUnEquip.slotMainDualContent.SetActive (false);
|
|
}
|
|
|
|
slotToUnEquip.secondarySlotActive = false;
|
|
|
|
slotToUnEquip.firstElementName = "";
|
|
slotToUnEquip.secondElementName = "";
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("unequipping slot " + slotToUnEquip.Name);
|
|
}
|
|
|
|
slotToUnEquip.Name = "";
|
|
slotToUnEquip.slotActive = false;
|
|
slotToUnEquip.amountText.text = "";
|
|
slotToUnEquip.slotIcon.texture = null;
|
|
slotToUnEquip.inventoryInfoAssigned = null;
|
|
|
|
if (slotToUnEquip.currentlySelectedIcon.activeSelf) {
|
|
slotToUnEquip.currentlySelectedIcon.SetActive (false);
|
|
}
|
|
|
|
if (slotToUnEquip.slotMainSingleContent.activeSelf) {
|
|
slotToUnEquip.slotMainSingleContent.SetActive (false);
|
|
}
|
|
|
|
if (slotToUnEquip.slotMainDualContent.activeSelf) {
|
|
slotToUnEquip.slotMainDualContent.SetActive (false);
|
|
}
|
|
|
|
if (hideEmptySlots && !inventoryOpened) {
|
|
if (slotToUnEquip.slot.activeSelf) {
|
|
slotToUnEquip.slot.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void updateQuickAccessSlotAmountByName (string objectName)
|
|
{
|
|
int quickAccessSlotIndex = currentQuickAccessList.FindIndex (s => s.Name == objectName);
|
|
|
|
if (quickAccessSlotIndex > -1) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [quickAccessSlotIndex];
|
|
|
|
if (currentSlotInfo.inventoryInfoAssigned != null) {
|
|
if (currentSlotInfo.inventoryInfoAssigned.amount <= 0) {
|
|
updateQuickAccessSlotInfo (-1, null, currentSlotInfo, null);
|
|
} else {
|
|
updateQuickAccesSlotAmount (quickAccessSlotIndex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void updateQuickAccesSlotAmount (int slotIndex)
|
|
{
|
|
if (quickAccessSlotInfoListCount > slotIndex) {
|
|
if (slotIndex == -1) {
|
|
slotIndex = quickAccessSlotInfoListCount - 1;
|
|
}
|
|
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [slotIndex];
|
|
|
|
if (currentSlotInfo.slotActive) {
|
|
if (currentSlotInfo.inventoryInfoAssigned.isWeapon) {
|
|
if (!currentSlotInfo.inventoryInfoAssigned.isMeleeWeapon) {
|
|
|
|
currentSlotInfo.amountText.text = currentSlotInfo.inventoryInfoAssigned.mainWeaponObjectInfo.getAmmoText ();
|
|
}
|
|
} else {
|
|
if (currentSlotInfo.inventoryInfoAssigned.infiniteAmount) {
|
|
currentSlotInfo.amountText.text = "Inf";
|
|
} else {
|
|
currentSlotInfo.amountText.text = currentSlotInfo.inventoryInfoAssigned.amount.ToString ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void updateAllQuickAccessSlotsAmount ()
|
|
{
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
updateQuickAccesSlotAmount (i);
|
|
}
|
|
}
|
|
|
|
public string getFirstSingleWeaponSlot (string weaponNameToAvoid)
|
|
{
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [i];
|
|
|
|
if (currentSlotInfo.slotActive &&
|
|
!currentSlotInfo.inventoryInfoAssigned.isMeleeWeapon &&
|
|
!currentSlotInfo.secondarySlotActive &&
|
|
(weaponNameToAvoid.Equals ("") || !weaponNameToAvoid.Equals (currentSlotInfo.Name))) {
|
|
|
|
return currentSlotInfo.Name;
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
|
|
public void showQuickAccessSlotsParentWhenSlotSelectedByName (string objectName)
|
|
{
|
|
if (showQuickAccessSlotsWhenChangingSlot) {
|
|
if (showDebugPrint) {
|
|
print ("show " + objectName + " " + mainInventoryManager.inventoryOpened);
|
|
}
|
|
|
|
for (int i = 0; i < quickAccessSlotInfoListCount; i++) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [i];
|
|
|
|
if (currentSlotInfo.slotActive && currentSlotInfo.inventoryInfoAssigned.Name.Equals (objectName)) {
|
|
int slotIndex = i + 1;
|
|
|
|
if (slotIndex >= 0 && quickAccessSlotInfoListCount >= slotIndex) {
|
|
stopShowQuickAccessSlotsParentWhenSlotSelectedCoroutuine ();
|
|
|
|
slotsParentCouroutine = StartCoroutine (showQuickAccessSlotsParentWhenSlotSelectedCoroutine (slotIndex));
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public void showQuickAccessSlotsParentWhenSlotSelected (int slotIndex)
|
|
{
|
|
if (showQuickAccessSlotsWhenChangingSlot) {
|
|
if (!mainInventoryManager.inventoryOpened) {
|
|
if (slotIndex >= 0 && quickAccessSlotInfoListCount >= slotIndex) {
|
|
stopShowQuickAccessSlotsParentWhenSlotSelectedCoroutuine ();
|
|
|
|
slotsParentCouroutine = StartCoroutine (showQuickAccessSlotsParentWhenSlotSelectedCoroutine (slotIndex));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stopShowQuickAccessSlotsParentWhenSlotSelectedCoroutuine ()
|
|
{
|
|
if (slotsParentCouroutine != null) {
|
|
StopCoroutine (slotsParentCouroutine);
|
|
}
|
|
}
|
|
|
|
IEnumerator showQuickAccessSlotsParentWhenSlotSelectedCoroutine (int slotIndex)
|
|
{
|
|
if (slotIndex >= 0 && quickAccessSlotInfoListCount >= slotIndex) {
|
|
|
|
bool isTurnBasedCombatActionActive = mainPlayerWeaponsManager.playerManager.isTurnBasedCombatActionActive ();
|
|
|
|
if (isTurnBasedCombatActionActive) {
|
|
if (!mainInventoryManager.inventoryOpened) {
|
|
moveQuickAccessSlotsToInventory ();
|
|
}
|
|
}
|
|
|
|
yield return new WaitForSeconds (0.001f);
|
|
|
|
if (!mainInventoryManager.inventoryOpened) {
|
|
if (!keepQuickAccessSlotsHiddenOnMainScreen && !isTurnBasedCombatActionActive) {
|
|
moveQuickAccessSlotsOutOfInventory ();
|
|
|
|
if (showQuickAccessSlotSelectedIcon) {
|
|
if (!quickAccessSlotSelectedIcon.activeSelf) {
|
|
quickAccessSlotSelectedIcon.SetActive (true);
|
|
}
|
|
|
|
quickAccessSlotSelectedIcon.transform.localScale = Vector3.one * quickAccessSlotsParentScale;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (slotIndex == 0) {
|
|
slotIndex = quickAccessSlotInfoListCount;
|
|
}
|
|
|
|
updateCurrentlySelectedSlotIcon (slotIndex, true);
|
|
|
|
updateAllQuickAccessSlotsAmount ();
|
|
|
|
yield return new WaitForSeconds (0.001f);
|
|
|
|
quickAccessSlotSelectedIcon.transform.position = currentQuickAccessList [slotIndex - 1].slotSelectedIconPosition.position;
|
|
|
|
yield return new WaitForSeconds (showQuickAccessSlotsParentDuration);
|
|
|
|
if (!showQuickAccessSlotsAlways || isTurnBasedCombatActionActive) {
|
|
moveQuickAccessSlotsToInventory ();
|
|
}
|
|
|
|
if (quickAccessSlotSelectedIcon.activeSelf) {
|
|
quickAccessSlotSelectedIcon.SetActive (false);
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("WARNING: weapon slot index not found when trying to show the top icon over the weapon selected in the weapon slots");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setShowQuickAccessSlotsAlwaysState (bool state)
|
|
{
|
|
showQuickAccessSlotsAlways = state;
|
|
}
|
|
|
|
public bool isShowQuickAccessSlotsAlwaysActive ()
|
|
{
|
|
return showQuickAccessSlotsAlways;
|
|
}
|
|
|
|
public void updateCurrentlySelectedSlotIcon (int slotIndex, bool activeCurrentQuickAccessSlot)
|
|
{
|
|
bool weaponsAvailable = mainPlayerWeaponsManager.checkIfWeaponsAvailable ();
|
|
|
|
bool anySlotActive = false;
|
|
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
if (!anySlotActive && currentQuickAccessList [j].slotActive) {
|
|
anySlotActive = true;
|
|
}
|
|
}
|
|
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [j];
|
|
|
|
bool currentIconActive = false;
|
|
|
|
if (activeCurrentQuickAccessSlot && (weaponsAvailable || anySlotActive)) {
|
|
if (j == slotIndex - 1) {
|
|
currentIconActive = true;
|
|
|
|
currentSlotIndex = j;
|
|
} else {
|
|
currentIconActive = false;
|
|
}
|
|
} else {
|
|
currentIconActive = false;
|
|
}
|
|
|
|
if (currentSlotInfo.currentlySelectedIcon.activeSelf != currentIconActive) {
|
|
currentSlotInfo.currentlySelectedIcon.SetActive (currentIconActive);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkModeToUpdateWeaponCurrentlySelectedIcon ()
|
|
{
|
|
if (mainPlayerWeaponsManager.isWeaponsModeActive ()) {
|
|
updateCurrentlySelectedSlotIcon (mainPlayerWeaponsManager.chooseDualWeaponIndex, true);
|
|
} else if (mainMeleeWeaponsGrabbedManager.isMeleeWeaponsGrabbedManagerActive ()) {
|
|
string weaponName = mainMeleeWeaponsGrabbedManager.getCurrentWeaponName ();
|
|
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [j];
|
|
|
|
if (currentSlotInfo.slotActive && currentSlotInfo.Name.Equals (weaponName)) {
|
|
|
|
updateCurrentlySelectedSlotIcon (j + 1, true);
|
|
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
if (currentSlotIndex != -1) {
|
|
updateCurrentlySelectedSlotIcon (currentSlotIndex + 1, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void disableCurrentlySelectedIcon ()
|
|
{
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
if (currentQuickAccessList [j].currentlySelectedIcon.activeSelf) {
|
|
currentQuickAccessList [j].currentlySelectedIcon.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool canUseInput ()
|
|
{
|
|
if (mainInventoryManager.playerIsBusy ()) {
|
|
return false;
|
|
}
|
|
|
|
if (mainInventoryManager.isGamePaused ()) {
|
|
return false;
|
|
}
|
|
|
|
if (mainPlayerWeaponsManager.isActionActiveInPlayer ()) {
|
|
return false;
|
|
}
|
|
|
|
if (!mainInventoryManager.canUseInput ()) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void selectQuickAccessSlotByPressingSlot (GameObject buttonToCheck)
|
|
{
|
|
if (!canUseInput ()) {
|
|
return;
|
|
}
|
|
|
|
if (!canSelectSlot ()) {
|
|
return;
|
|
}
|
|
|
|
if (mainInventoryManager.inventoryOpened) {
|
|
return;
|
|
}
|
|
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [j];
|
|
|
|
if (currentSlotInfo.slot == buttonToCheck) {
|
|
checkQuickAccessSlotToSelect (j);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void moveQuickAccessSlotsOutOfInventory ()
|
|
{
|
|
inventoryQuickAccessSlots.transform.SetParent (quickAccessSlotsParentOutOfInventory);
|
|
inventoryQuickAccessSlots.transform.localScale = Vector3.one * quickAccessSlotsParentScale;
|
|
inventoryQuickAccessSlots.transform.localPosition = Vector3.zero;
|
|
|
|
setQuickAccessSlotsBackgroundColorAlphaValue (quickAccessSlotsAlphaValueOutOfInventory);
|
|
}
|
|
|
|
public void moveQuickAccessSlotsToInventory ()
|
|
{
|
|
inventoryQuickAccessSlots.transform.SetParent (quickAccessSlotsParentOnInventory);
|
|
|
|
inventoryQuickAccessSlots.transform.localScale = Vector3.one;
|
|
inventoryQuickAccessSlots.transform.localPosition = Vector3.zero;
|
|
|
|
if (quickAccessSlotSelectedIcon.activeSelf) {
|
|
quickAccessSlotSelectedIcon.SetActive (false);
|
|
}
|
|
|
|
setQuickAccessSlotsBackgroundColorAlphaValue (1);
|
|
}
|
|
|
|
public void setQuickAccessSlotsBackgroundColorAlphaValue (float newAlphaValue)
|
|
{
|
|
if (!setQuickAccessSlotsAlphaValueOutOfInventory) {
|
|
return;
|
|
}
|
|
|
|
for (int j = 0; j < quickAccessSlotInfoListCount; j++) {
|
|
inventoryQuickAccessSlotElement.quickAccessSlotInfo currentSlotInfo = currentQuickAccessList [j];
|
|
|
|
Color currentColor = currentSlotInfo.backgroundImage.color;
|
|
|
|
currentColor.a = newAlphaValue;
|
|
|
|
currentSlotInfo.backgroundImage.color = currentColor;
|
|
}
|
|
}
|
|
|
|
public void enableOrDisableHUD (bool state)
|
|
{
|
|
enableOrDisableQuickAccessSlotsParentOutOfInventory (state);
|
|
}
|
|
|
|
public void enableOrDisableQuickAccessSlotsParentOutOfInventory (bool state)
|
|
{
|
|
if (showQuickAccessSlotsPaused) {
|
|
return;
|
|
}
|
|
|
|
setQuickAccessSlotsParentOutOfInventoryActiveState (state);
|
|
}
|
|
|
|
public void checkToEnableOrDisableQuickAccessSlotsParentOutOfInventory (bool state)
|
|
{
|
|
if (showQuickAccessSlotsPaused) {
|
|
return;
|
|
}
|
|
|
|
if (showQuickAccessSlotsAlways) {
|
|
setQuickAccessSlotsParentOutOfInventoryActiveState (state);
|
|
}
|
|
}
|
|
|
|
public void checkToEnableOrDisableQuickAccessSlotsParentOutOfInventoryFromFireWeaponsMode (bool state)
|
|
{
|
|
if (showQuickAccessSlotsPaused) {
|
|
return;
|
|
}
|
|
|
|
if (!disableQuickAccessSlotsWhenChangingFromFireWeaponsMode && !state) {
|
|
return;
|
|
}
|
|
|
|
if (showQuickAccessSlotsAlways) {
|
|
setQuickAccessSlotsParentOutOfInventoryActiveState (state);
|
|
}
|
|
}
|
|
|
|
public void checkToEnableOrDisableQuickAccessSlotsParentOutOfInventoryFromMeleeWeaponsMode (bool state)
|
|
{
|
|
if (showQuickAccessSlotsPaused) {
|
|
return;
|
|
}
|
|
|
|
if (!disableQuickAccessSlotsWhenChangingFromMeleeWeaponsMode && !state) {
|
|
return;
|
|
}
|
|
|
|
if (showQuickAccessSlotsAlways) {
|
|
setQuickAccessSlotsParentOutOfInventoryActiveState (state);
|
|
}
|
|
}
|
|
|
|
void setQuickAccessSlotsParentOutOfInventoryActiveState (bool state)
|
|
{
|
|
if (quickAccessSlotsParentOutOfInventory.gameObject.activeSelf != state) {
|
|
quickAccessSlotsParentOutOfInventory.gameObject.SetActive (state);
|
|
}
|
|
}
|
|
|
|
public void setInventoryQuickAccessSlotsActiveState (bool state)
|
|
{
|
|
if (inventoryQuickAccessSlots.activeSelf != state) {
|
|
inventoryQuickAccessSlots.SetActive (state);
|
|
}
|
|
}
|
|
|
|
public void setShowQuickAccessSlotsPausedState (bool state)
|
|
{
|
|
showQuickAccessSlotsPaused = state;
|
|
}
|
|
|
|
public void resetDragAndDropSlotState ()
|
|
{
|
|
activatingDualWeaponSlot = false;
|
|
|
|
mainInventoryManager.setActivatingDualWeaponSlotState (activatingDualWeaponSlot);
|
|
|
|
if (quickAccessSlotToMove.activeSelf) {
|
|
quickAccessSlotToMove.SetActive (false);
|
|
}
|
|
|
|
slotFoundOnDrop = null;
|
|
|
|
draggedFromInventoryList = false;
|
|
|
|
draggedFromQuickAccessSlots = false;
|
|
|
|
slotToMoveFound = false;
|
|
}
|
|
|
|
public void setOpenOrCloseInventoryMenuState (bool state)
|
|
{
|
|
inventoryOpened = state;
|
|
|
|
resetDragAndDropSlotState ();
|
|
|
|
touching = false;
|
|
|
|
enableOrDisableAllQuickAccessSlots (state);
|
|
}
|
|
|
|
public void setCustomizingCharacterActiveState (bool state)
|
|
{
|
|
customizingCharacterActive = state;
|
|
|
|
if (customizingCharacterActive) {
|
|
currentQuickAccessList = characterCustomizationSlotList;
|
|
} else {
|
|
currentQuickAccessList = quickAccessSlotInfoList;
|
|
}
|
|
|
|
quickAccessSlotInfoListCount = currentQuickAccessList.Count;
|
|
}
|
|
|
|
public bool isCustomizingCharacterActive ()
|
|
{
|
|
return customizingCharacterActive;
|
|
}
|
|
|
|
public List<inventoryQuickAccessSlotElement.quickAccessSlotInfo> getCurrentQuickAccessList ()
|
|
{
|
|
return currentQuickAccessList;
|
|
}
|
|
|
|
public void setCheckObjectCategoriesToUseActiveState (bool state)
|
|
{
|
|
checkObjectCategoriesToUseActive = state;
|
|
}
|
|
|
|
public void setCurrentCategoryListToUseActive (List<string> newList)
|
|
{
|
|
currentCategoryListToUseActive = newList;
|
|
}
|
|
|
|
public void setCheckSlotsCategoryNameToDropActive (bool state)
|
|
{
|
|
checkSlotsCategoryNameToDrop = state;
|
|
}
|
|
|
|
public void setKeepQuickAccessSlotsHiddenOnMainScreenState (bool state)
|
|
{
|
|
keepQuickAccessSlotsHiddenOnMainScreen = state;
|
|
}
|
|
|
|
//EDITOR FUNCTIONS
|
|
public void setShowQuickAccessSlotsAlwaysStateFromEditor (bool state)
|
|
{
|
|
setShowQuickAccessSlotsAlwaysState (state);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
public void setKeepQuickAccessSlotsHiddenOnMainScreenStateFromEditor (bool state)
|
|
{
|
|
setKeepQuickAccessSlotsHiddenOnMainScreenState (state);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
void updateComponent ()
|
|
{
|
|
GKC_Utils.updateComponent (this);
|
|
|
|
GKC_Utils.updateDirtyScene ("Update Quick Access Slots System", gameObject);
|
|
}
|
|
}
|