1894 lines
64 KiB
C#
1894 lines
64 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
using System.IO;
|
|
using System;
|
|
using UnityEngine.Events;
|
|
using UnityEngine.EventSystems;
|
|
using GKC.Localization;
|
|
using System.Reflection;
|
|
|
|
public class inventoryBankUISystem : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public bool useNumberOfElementsOnPressUp;
|
|
public bool useNumberOfElementsWhenIconNotMoved;
|
|
public bool dropFullObjectsAmount = true;
|
|
public bool dragAndDropIcons = true;
|
|
|
|
public float timeToDrag = 0.5f;
|
|
|
|
public float configureNumberObjectsToUseRate = 0.4f;
|
|
public float fasterNumberObjectsToUseRate = 0.1f;
|
|
public float waitTimeToUseFasterNumberObjectsToUseRate = 1;
|
|
|
|
public string mainInventoryManagerName = "Main Inventory Manager";
|
|
|
|
public bool allowToDropPlayerInventoryIntoCustomInventoryBanks;
|
|
|
|
public bool closeMenuIfInventoryBankObjectDestroyed;
|
|
|
|
public bool allowToSelectNewSlotObjectIfSettingAmountOnPreviousEnabled = true;
|
|
|
|
[Space]
|
|
|
|
public string inventoryBankFullMessage = "Inventory Bank is full";
|
|
|
|
[Space]
|
|
|
|
public bool useCustomMaxInventoryBankSlotsAmount;
|
|
|
|
public bool showEmptySlotsOnUseMaxInventoryBankSlotsAmount;
|
|
|
|
public bool useMaxInventoryBankSlotsAmount;
|
|
public int maxInventoryBankSlotsAmount;
|
|
|
|
[Space]
|
|
[Header ("Zoom/Rotation Settings")]
|
|
[Space]
|
|
|
|
public float zoomSpeed;
|
|
public float maxZoomValue;
|
|
public float minZoomValue;
|
|
public float rotationSpeed;
|
|
|
|
public bool useBlurUIPanel = true;
|
|
|
|
[Space]
|
|
[Header ("Debug State")]
|
|
[Space]
|
|
|
|
public bool menuOpened;
|
|
|
|
public bool slotToMoveFound;
|
|
public GameObject slotFound;
|
|
public bool draggedFromPlayerInventoryList;
|
|
public bool draggedFromBankInventoryList;
|
|
public bool droppedInPlayerInventoryList;
|
|
public bool droppedInBankInventoryList;
|
|
|
|
public bool canDropObjectsToInventoryBank = true;
|
|
public bool touching;
|
|
|
|
public bool draggingSlotActive;
|
|
|
|
public bool resetDragDropElementsEnabled = true;
|
|
|
|
public inventoryInfo currentSlotToMoveInventoryObject;
|
|
public inventoryInfo currentSlotFoundInventoryObject;
|
|
|
|
[Space]
|
|
[Header ("Debug List")]
|
|
[Space]
|
|
|
|
public List<inventoryInfo> playerInventoryList = new List<inventoryInfo> ();
|
|
|
|
[Space]
|
|
|
|
public List<inventoryInfo> currentBankInventoryList = new List<inventoryInfo> ();
|
|
|
|
[Space]
|
|
|
|
public List<inventoryMenuIconElement> playerIconElementList = new List<inventoryMenuIconElement> ();
|
|
public List<inventoryMenuIconElement> bankIconElementList = new List<inventoryMenuIconElement> ();
|
|
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
|
|
[Space]
|
|
[Header ("Event Settings")]
|
|
[Space]
|
|
|
|
public bool useEventsOnOpenCloseInventoryBank;
|
|
public UnityEvent eventOnOpenInventoryBank;
|
|
public UnityEvent eventOnCloseInventoryBank;
|
|
|
|
[Space]
|
|
[Header ("UI Elements")]
|
|
[Space]
|
|
|
|
public RawImage inventoryMenuRenderTexture;
|
|
|
|
public Transform lookObjectsPosition;
|
|
|
|
public GameObject slotToMove;
|
|
public GameObject menuBackground;
|
|
public GameObject inventoryObjectRenderPanel;
|
|
|
|
public Camera inventoryCamera;
|
|
|
|
public GameObject inventoryMenu;
|
|
|
|
public GameObject playerInventorySlots;
|
|
public GameObject playerInventorySlotsContent;
|
|
public GameObject playerInventorySlot;
|
|
public Scrollbar playerInventoryScrollbar;
|
|
|
|
public GameObject bankInventorySlots;
|
|
public GameObject bankInventorySlotsContent;
|
|
public GameObject bankInventorySlot;
|
|
public Scrollbar bankInventoryScrollbar;
|
|
|
|
public GameObject numberOfElementsWindow;
|
|
public Text numberOfObjectsToUseText;
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public inventoryManager playerInventoryManager;
|
|
|
|
public usingDevicesSystem usingDevicesManager;
|
|
|
|
public inventoryListManager mainInventoryListManager;
|
|
|
|
public inventoryBankManager mainInventoryBankManager;
|
|
|
|
public playerInputManager playerInput;
|
|
|
|
public menuPause pauseManager;
|
|
|
|
inventoryInfo currentInventoryObject;
|
|
Coroutine resetCameraFov;
|
|
|
|
float originalFov;
|
|
GameObject objectInCamera;
|
|
int numberOfObjectsToUse;
|
|
|
|
bool touchPlatform;
|
|
|
|
Touch currentTouch;
|
|
readonly List<RaycastResult> captureRaycastResults = new List<RaycastResult> ();
|
|
|
|
bool zoomingIn;
|
|
bool zoomingOut;
|
|
|
|
bool enableRotation;
|
|
|
|
inventoryBankSystem currentInventoryBankSystem;
|
|
|
|
GameObject currentInventoryBankObject;
|
|
|
|
bool useInventoryFromThisBank;
|
|
|
|
int objectToMoveIndex;
|
|
int objectFoundIndex;
|
|
|
|
int currentAmountToMove;
|
|
int currentBankInventoryListIndex;
|
|
bool currentObjectAlreadyInBankList;
|
|
bool settingAmountObjectsToMove;
|
|
|
|
float lastTimeTouched;
|
|
|
|
bool addingObjectToUse;
|
|
bool removinvObjectToUse;
|
|
float lastTimeAddObjectToUse;
|
|
float lastTimeRemoveObjectToUse;
|
|
bool useFasterNumberObjectsToUseRateActive;
|
|
float lastTimeConfigureNumberOfObjects;
|
|
|
|
inventoryObject currentInventoryObjectManager;
|
|
float currentMaxZoomValue;
|
|
float currentMinZoomValue;
|
|
|
|
Vector2 axisValues;
|
|
|
|
bool mainInventoryManagerLocated;
|
|
|
|
Coroutine updateCoroutine;
|
|
|
|
float lastTimeSlotToMoveFound = 0;
|
|
|
|
bool replacingObjectsActive;
|
|
|
|
|
|
void Start ()
|
|
{
|
|
originalFov = inventoryCamera.fieldOfView;
|
|
|
|
inventoryMenu.SetActive (false);
|
|
|
|
playerInventorySlot.SetActive (false);
|
|
|
|
bankInventorySlot.SetActive (false);
|
|
|
|
touchPlatform = touchJoystick.checkTouchPlatform ();
|
|
}
|
|
|
|
void checkGetMainInventoryManager ()
|
|
{
|
|
if (!mainInventoryManagerLocated) {
|
|
mainInventoryManagerLocated = mainInventoryListManager != null;
|
|
|
|
if (!mainInventoryManagerLocated) {
|
|
mainInventoryListManager = inventoryListManager.Instance;
|
|
|
|
mainInventoryManagerLocated = mainInventoryListManager != null;
|
|
}
|
|
|
|
if (!mainInventoryManagerLocated) {
|
|
GKC_Utils.instantiateMainManagerOnSceneWithTypeOnApplicationPlaying (inventoryListManager.getMainManagerName (), typeof (inventoryListManager), true);
|
|
|
|
mainInventoryListManager = inventoryListManager.Instance;
|
|
|
|
mainInventoryManagerLocated = (mainInventoryListManager != null);
|
|
}
|
|
|
|
if (!mainInventoryManagerLocated) {
|
|
mainInventoryListManager = FindObjectOfType<inventoryListManager> ();
|
|
|
|
mainInventoryManagerLocated = mainInventoryListManager != null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stopUpdateCoroutine ()
|
|
{
|
|
if (updateCoroutine != null) {
|
|
StopCoroutine (updateCoroutine);
|
|
}
|
|
}
|
|
|
|
IEnumerator updateSystemCoroutine ()
|
|
{
|
|
var waitTime = new WaitForSecondsRealtime (0.00001f);
|
|
|
|
while (true) {
|
|
updateSystem ();
|
|
|
|
yield return waitTime;
|
|
}
|
|
}
|
|
|
|
void updateSystem ()
|
|
{
|
|
if (menuOpened) {
|
|
if (enableRotation) {
|
|
axisValues = playerInput.getPlayerMouseAxis ();
|
|
objectInCamera.transform.Rotate (inventoryCamera.transform.up, -Mathf.Deg2Rad * rotationSpeed * axisValues.x, Space.World);
|
|
objectInCamera.transform.Rotate (inventoryCamera.transform.right, Mathf.Deg2Rad * rotationSpeed * axisValues.y, Space.World);
|
|
}
|
|
|
|
if (currentInventoryObjectManager != null && currentInventoryObjectManager.useZoomRange) {
|
|
currentMaxZoomValue = currentInventoryObjectManager.maxZoom;
|
|
currentMinZoomValue = currentInventoryObjectManager.minZoom;
|
|
} else {
|
|
currentMaxZoomValue = maxZoomValue;
|
|
currentMinZoomValue = minZoomValue;
|
|
}
|
|
|
|
if (zoomingIn) {
|
|
if (inventoryCamera.fieldOfView > currentMaxZoomValue) {
|
|
inventoryCamera.fieldOfView -= Time.deltaTime * zoomSpeed;
|
|
} else {
|
|
inventoryCamera.fieldOfView = currentMaxZoomValue;
|
|
}
|
|
}
|
|
|
|
if (zoomingOut) {
|
|
if (inventoryCamera.fieldOfView < currentMinZoomValue) {
|
|
inventoryCamera.fieldOfView += Time.deltaTime * zoomSpeed;
|
|
} else {
|
|
inventoryCamera.fieldOfView = currentMinZoomValue;
|
|
}
|
|
}
|
|
|
|
if (addingObjectToUse) {
|
|
if (!useFasterNumberObjectsToUseRateActive) {
|
|
if (Time.time > configureNumberObjectsToUseRate + lastTimeAddObjectToUse) {
|
|
|
|
lastTimeAddObjectToUse = Time.time;
|
|
|
|
addObjectToUse ();
|
|
}
|
|
|
|
if (Time.time > lastTimeConfigureNumberOfObjects + waitTimeToUseFasterNumberObjectsToUseRate) {
|
|
useFasterNumberObjectsToUseRateActive = true;
|
|
}
|
|
} else {
|
|
if (Time.time > fasterNumberObjectsToUseRate + lastTimeAddObjectToUse) {
|
|
lastTimeAddObjectToUse = Time.time;
|
|
|
|
addObjectToUse ();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (removinvObjectToUse) {
|
|
if (!useFasterNumberObjectsToUseRateActive) {
|
|
if (Time.time > configureNumberObjectsToUseRate + lastTimeRemoveObjectToUse) {
|
|
|
|
lastTimeRemoveObjectToUse = Time.time;
|
|
|
|
removeObjectToUse ();
|
|
}
|
|
|
|
if (Time.time > lastTimeConfigureNumberOfObjects + waitTimeToUseFasterNumberObjectsToUseRate) {
|
|
useFasterNumberObjectsToUseRateActive = true;
|
|
}
|
|
} else {
|
|
if (Time.time > fasterNumberObjectsToUseRate + lastTimeRemoveObjectToUse) {
|
|
lastTimeRemoveObjectToUse = Time.time;
|
|
|
|
removeObjectToUse ();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (settingAmountObjectsToMove && !allowToSelectNewSlotObjectIfSettingAmountOnPreviousEnabled) {
|
|
return;
|
|
}
|
|
|
|
checkInventoryObjectSlotsInput ();
|
|
|
|
if (closeMenuIfInventoryBankObjectDestroyed) {
|
|
if (currentInventoryBankObject == null && currentInventoryBankSystem == null) {
|
|
openOrCloseInventoryBankMenuByButton ();
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setCurrentInventoryBankObject (GameObject inventoryBankGameObject)
|
|
{
|
|
currentInventoryBankObject = inventoryBankGameObject;
|
|
}
|
|
|
|
public void setCurrentInventoryBankSystem (GameObject inventoryBankGameObject)
|
|
{
|
|
currentInventoryBankSystem = inventoryBankGameObject.GetComponent<inventoryBankSystem> ();
|
|
|
|
useInventoryFromThisBank = currentInventoryBankSystem.useInventoryFromThisBank;
|
|
|
|
if (useInventoryFromThisBank) {
|
|
currentBankInventoryList = currentInventoryBankSystem.getBankInventoryList ();
|
|
|
|
if (!allowToDropPlayerInventoryIntoCustomInventoryBanks) {
|
|
canDropObjectsToInventoryBank = false;
|
|
}
|
|
|
|
if (!useCustomMaxInventoryBankSlotsAmount) {
|
|
useMaxInventoryBankSlotsAmount = currentInventoryBankSystem.useMaxInventoryBankSlotsAmount;
|
|
maxInventoryBankSlotsAmount = currentInventoryBankSystem.maxInventoryBankSlotsAmount;
|
|
}
|
|
} else {
|
|
mainInventoryListManager = inventoryListManager.Instance;
|
|
|
|
bool mainInventoryManagerLocated = mainInventoryListManager != null;
|
|
|
|
if (!mainInventoryManagerLocated) {
|
|
GKC_Utils.instantiateMainManagerOnSceneWithTypeOnApplicationPlaying (inventoryListManager.getMainManagerName (), typeof (inventoryListManager), true);
|
|
|
|
mainInventoryListManager = inventoryListManager.Instance;
|
|
|
|
mainInventoryManagerLocated = (mainInventoryListManager != null);
|
|
}
|
|
|
|
if (!mainInventoryManagerLocated) {
|
|
mainInventoryListManager = FindObjectOfType<inventoryListManager> ();
|
|
|
|
mainInventoryManagerLocated = mainInventoryListManager != null;
|
|
}
|
|
|
|
if (mainInventoryManagerLocated) {
|
|
mainInventoryBankManager = mainInventoryListManager.getMainInventoryBankManager ();
|
|
}
|
|
|
|
if (mainInventoryBankManager != null) {
|
|
currentBankInventoryList = mainInventoryBankManager.getBankInventoryList ();
|
|
|
|
if (!useCustomMaxInventoryBankSlotsAmount) {
|
|
useMaxInventoryBankSlotsAmount = mainInventoryBankManager.useMaxInventoryBankSlotsAmount;
|
|
maxInventoryBankSlotsAmount = mainInventoryBankManager.maxInventoryBankSlotsAmount;
|
|
}
|
|
} else {
|
|
print ("WARNING: No Inventory Bank Manager found in the scene, make sure to add the Main Inventory Manager prefab to the scene");
|
|
}
|
|
|
|
canDropObjectsToInventoryBank = true;
|
|
}
|
|
|
|
menuBackground.SetActive (!useInventoryFromThisBank);
|
|
|
|
inventoryObjectRenderPanel.SetActive (!useInventoryFromThisBank);
|
|
}
|
|
|
|
public void openOrCloseInventoryBankMenuByButton ()
|
|
{
|
|
bool vendorObjectNotFound = false;
|
|
|
|
bool currentInventoryBankObjectNotFound = false;
|
|
|
|
if (usingDevicesManager != null) {
|
|
if (currentInventoryBankObject != null) {
|
|
if (usingDevicesManager.existInDeviceList (currentInventoryBankObject)) {
|
|
usingDevicesManager.useDevice ();
|
|
} else {
|
|
usingDevicesManager.useCurrentDevice (currentInventoryBankObject);
|
|
|
|
vendorObjectNotFound = true;
|
|
}
|
|
} else {
|
|
usingDevicesManager.useDevice ();
|
|
|
|
currentInventoryBankObjectNotFound = true;
|
|
}
|
|
}
|
|
|
|
if (currentInventoryBankSystem != null) {
|
|
currentInventoryBankSystem.setUsingInventoryBankState (menuOpened);
|
|
}
|
|
|
|
if (vendorObjectNotFound) {
|
|
if (usingDevicesManager != null) {
|
|
usingDevicesManager.removeDeviceFromList (currentInventoryBankObject);
|
|
|
|
usingDevicesManager.updateClosestDeviceList ();
|
|
}
|
|
}
|
|
|
|
if (currentInventoryBankObjectNotFound) {
|
|
closeInventoryBankIfDestroyed ();
|
|
}
|
|
}
|
|
|
|
public void closeInventoryBankIfDestroyed ()
|
|
{
|
|
if (menuOpened) {
|
|
if (currentInventoryBankSystem == null) {
|
|
pauseManager.setUsingDeviceState (false);
|
|
|
|
openOrCloseInventoryBankMenu (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void openOrCloseInventoryBankMenu (bool state)
|
|
{
|
|
menuOpened = state;
|
|
|
|
stopUpdateCoroutine ();
|
|
|
|
setMenuIconElementPressedState (false);
|
|
|
|
pauseManager.openOrClosePlayerMenu (menuOpened, inventoryMenu.transform, useBlurUIPanel);
|
|
|
|
inventoryMenu.SetActive (menuOpened);
|
|
|
|
pauseManager.setIngameMenuOpenedState ("Inventory Bank Manager", menuOpened, true);
|
|
|
|
if (menuOpened) {
|
|
int bankIconElementListCount = bankIconElementList.Count;
|
|
|
|
for (int i = 0; i < bankIconElementListCount; i++) {
|
|
if (bankIconElementList [i].button != null && bankIconElementList [i].button.gameObject.activeSelf) {
|
|
bankIconElementList [i].button.gameObject.SetActive (false);
|
|
}
|
|
}
|
|
|
|
int playerInventoryListCount = playerInventoryList.Count;
|
|
|
|
for (int i = 0; i < playerInventoryListCount; i++) {
|
|
if (playerInventoryList [i].button != null && playerInventoryList [i].button.gameObject.activeSelf) {
|
|
playerInventoryList [i].button.gameObject.SetActive (false);
|
|
}
|
|
}
|
|
|
|
getCurrentPlayerInventoryList ();
|
|
|
|
checkMaximumAmountPerSlotOnInventoryList (currentBankInventoryList);
|
|
|
|
createInventoryIcons (playerInventoryList, playerInventorySlot, playerInventorySlotsContent, playerIconElementList);
|
|
|
|
if (showEmptySlotsOnUseMaxInventoryBankSlotsAmount) {
|
|
int extraEmptyInventorySlots = Math.Abs (currentBankInventoryList.Count - maxInventoryBankSlotsAmount);
|
|
|
|
for (int i = 0; i < extraEmptyInventorySlots; i++) {
|
|
currentBankInventoryList.Add (new inventoryInfo ());
|
|
}
|
|
}
|
|
|
|
createInventoryIcons (currentBankInventoryList, bankInventorySlot, bankInventorySlotsContent, bankIconElementList);
|
|
|
|
playerInventorySlotsContent.GetComponentInParent<ScrollRect> ().verticalNormalizedPosition = 0.5f;
|
|
bankInventorySlotsContent.GetComponentInParent<ScrollRect> ().verticalNormalizedPosition = 0.5f;
|
|
|
|
resetScroll (bankInventoryScrollbar);
|
|
resetScroll (playerInventoryScrollbar);
|
|
}
|
|
|
|
pauseManager.enableOrDisablePlayerMenu (menuOpened, true, false);
|
|
|
|
destroyObjectInCamera ();
|
|
|
|
resetAndDisableNumberOfObjectsToUseMenu ();
|
|
|
|
inventoryCamera.fieldOfView = originalFov;
|
|
currentInventoryObject = null;
|
|
inventoryCamera.enabled = menuOpened;
|
|
|
|
currentInventoryObjectManager = null;
|
|
|
|
if (!menuOpened) {
|
|
resetDragDropElements ();
|
|
}
|
|
|
|
if (menuOpened) {
|
|
updateCoroutine = StartCoroutine (updateSystemCoroutine ());
|
|
}
|
|
|
|
checkEventsOnOpenCloseInventoryBank (menuOpened);
|
|
}
|
|
|
|
void checkEventsOnOpenCloseInventoryBank (bool state)
|
|
{
|
|
if (useEventsOnOpenCloseInventoryBank) {
|
|
if (state) {
|
|
eventOnOpenInventoryBank.Invoke ();
|
|
} else {
|
|
eventOnCloseInventoryBank.Invoke ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void createInventoryIcons (List<inventoryInfo> currentInventoryListToCreate, GameObject currentInventorySlot, GameObject currentInventorySlotsContent,
|
|
List<inventoryMenuIconElement> currentIconElementList)
|
|
{
|
|
for (int i = 0; i < currentInventoryListToCreate.Count; i++) {
|
|
if (currentInventoryListToCreate [i].button != null && currentInventoryListToCreate [i].button.gameObject.activeSelf) {
|
|
currentInventoryListToCreate [i].button.gameObject.SetActive (false);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < currentInventoryListToCreate.Count; i++) {
|
|
createInventoryIcon (currentInventoryListToCreate [i], i, currentInventorySlot, currentInventorySlotsContent, currentIconElementList);
|
|
}
|
|
}
|
|
|
|
public void createInventoryIcon (inventoryInfo currentInventoryInfo, int index, GameObject currentInventorySlot, GameObject currentInventorySlotsContent,
|
|
List<inventoryMenuIconElement> currentIconElementList)
|
|
{
|
|
GameObject newIconButton = null;
|
|
|
|
bool createNewIconResult = true;
|
|
|
|
if (currentIconElementList.Count > 0) {
|
|
for (int i = 0; i < currentIconElementList.Count; i++) {
|
|
if (createNewIconResult) {
|
|
if (!currentIconElementList [i].button.gameObject.activeSelf) {
|
|
createNewIconResult = false;
|
|
|
|
newIconButton = currentIconElementList [i].button.gameObject;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (createNewIconResult) {
|
|
newIconButton = (GameObject)Instantiate (currentInventorySlot, Vector3.zero, Quaternion.identity, currentInventorySlotsContent.transform);
|
|
}
|
|
|
|
if (!newIconButton.activeSelf) {
|
|
newIconButton.SetActive (true);
|
|
}
|
|
|
|
newIconButton.transform.localScale = Vector3.one;
|
|
newIconButton.transform.localPosition = Vector3.zero;
|
|
|
|
inventoryMenuIconElement menuIconElement = newIconButton.GetComponent<inventoryMenuIconElement> ();
|
|
|
|
string currentInventoryInfoName = currentInventoryInfo.Name;
|
|
|
|
if (gameLanguageSelector.isCheckLanguageActive ()) {
|
|
currentInventoryInfoName = inventoryLocalizationManager.GetLocalizedValue (currentInventoryInfoName);
|
|
}
|
|
|
|
menuIconElement.iconName.text = currentInventoryInfoName;
|
|
|
|
if (currentInventoryInfo.inventoryGameObject != null) {
|
|
menuIconElement.icon.texture = currentInventoryInfo.icon;
|
|
} else {
|
|
menuIconElement.icon.texture = null;
|
|
}
|
|
|
|
menuIconElement.amount.text = currentInventoryInfo.amount.ToString ();
|
|
|
|
menuIconElement.pressedIcon.SetActive (false);
|
|
|
|
newIconButton.name = "Inventory Object-" + (index + 1);
|
|
|
|
Button button = menuIconElement.button;
|
|
currentInventoryInfo.button = button;
|
|
currentInventoryInfo.menuIconElement = menuIconElement;
|
|
|
|
bool slotIsActive = currentInventoryInfo.amount > 0;
|
|
|
|
if (currentInventoryInfo.menuIconElement.activeSlotContent != null) {
|
|
currentInventoryInfo.menuIconElement.activeSlotContent.SetActive (slotIsActive);
|
|
}
|
|
|
|
if (currentInventoryInfo.menuIconElement.emptySlotContent != null) {
|
|
currentInventoryInfo.menuIconElement.emptySlotContent.SetActive (!slotIsActive);
|
|
}
|
|
|
|
if (createNewIconResult) {
|
|
currentIconElementList.Add (menuIconElement);
|
|
}
|
|
}
|
|
|
|
public void enableNumberOfElementsOnPressUp ()
|
|
{
|
|
if (dragAndDropIcons && (!dropFullObjectsAmount || useNumberOfElementsWhenIconNotMoved)) {
|
|
enableNumberOfObjectsToUseMenu (currentSlotToMoveInventoryObject.button.GetComponent<RectTransform> ());
|
|
|
|
if (draggedFromPlayerInventoryList) {
|
|
droppedInBankInventoryList = true;
|
|
droppedInPlayerInventoryList = false;
|
|
}
|
|
|
|
if (draggedFromBankInventoryList) {
|
|
droppedInPlayerInventoryList = true;
|
|
droppedInBankInventoryList = false;
|
|
}
|
|
|
|
draggedFromPlayerInventoryList = true;
|
|
draggedFromBankInventoryList = true;
|
|
}
|
|
}
|
|
|
|
public void enableObjectRotation ()
|
|
{
|
|
if (objectInCamera) {
|
|
enableRotation = true;
|
|
}
|
|
}
|
|
|
|
public void disableObjectRotation ()
|
|
{
|
|
enableRotation = false;
|
|
}
|
|
|
|
public void destroyObjectInCamera ()
|
|
{
|
|
if (objectInCamera) {
|
|
Destroy (objectInCamera);
|
|
}
|
|
}
|
|
|
|
public void zoomInEnabled ()
|
|
{
|
|
zoomingIn = true;
|
|
}
|
|
|
|
public void zoomInDisabled ()
|
|
{
|
|
zoomingIn = false;
|
|
}
|
|
|
|
public void zoomOutEnabled ()
|
|
{
|
|
zoomingOut = true;
|
|
}
|
|
|
|
public void zoomOutDisabled ()
|
|
{
|
|
zoomingOut = false;
|
|
}
|
|
|
|
public void checkResetCameraFov (float targetValue)
|
|
{
|
|
if (resetCameraFov != null) {
|
|
StopCoroutine (resetCameraFov);
|
|
}
|
|
|
|
resetCameraFov = StartCoroutine (resetCameraFovCorutine (targetValue));
|
|
}
|
|
|
|
IEnumerator resetCameraFovCorutine (float targetValue)
|
|
{
|
|
while (inventoryCamera.fieldOfView != targetValue) {
|
|
inventoryCamera.fieldOfView = Mathf.MoveTowards (inventoryCamera.fieldOfView, targetValue, Time.deltaTime * zoomSpeed);
|
|
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
public void getCurrentPlayerInventoryList ()
|
|
{
|
|
playerInventoryList.Clear ();
|
|
|
|
for (int i = 0; i < playerInventoryManager.inventoryList.Count; i++) {
|
|
|
|
inventoryInfo newPlayerInventoryObjectInfo = new inventoryInfo (playerInventoryManager.inventoryList [i]);
|
|
|
|
newPlayerInventoryObjectInfo.button = null;
|
|
|
|
playerInventoryList.Add (newPlayerInventoryObjectInfo);
|
|
}
|
|
|
|
checkMaximumAmountPerSlotOnInventoryList (playerInventoryList);
|
|
}
|
|
|
|
void checkMaximumAmountPerSlotOnInventoryList (List<inventoryInfo> currentInventoryList)
|
|
{
|
|
int currentInventoryListCount = currentInventoryList.Count;
|
|
|
|
for (int i = 0; i < currentInventoryListCount; i++) {
|
|
inventoryInfo currentInventoryInfo = currentInventoryList [i];
|
|
|
|
if (currentInventoryInfo.setMaximumAmountPerSlot) {
|
|
bool allAmountTaken = false;
|
|
|
|
int currentAmountPerSlot = currentInventoryInfo.maximumAmountPerSlot;
|
|
|
|
int totalAmountToTake = 0;
|
|
|
|
bool checkRestAmount = true;
|
|
|
|
if (currentInventoryInfo.amount > currentAmountPerSlot) {
|
|
totalAmountToTake = currentInventoryInfo.amount - currentAmountPerSlot;
|
|
|
|
currentInventoryInfo.amount = currentAmountPerSlot;
|
|
} else {
|
|
checkRestAmount = false;
|
|
}
|
|
|
|
if (checkRestAmount) {
|
|
int loopCount = 0;
|
|
|
|
while (!allAmountTaken) {
|
|
inventoryInfo duplicatedInventoryInfo = new inventoryInfo (currentInventoryInfo);
|
|
|
|
if (totalAmountToTake - currentAmountPerSlot >= 0) {
|
|
duplicatedInventoryInfo.amount = currentAmountPerSlot;
|
|
|
|
totalAmountToTake -= currentAmountPerSlot;
|
|
} else {
|
|
duplicatedInventoryInfo.amount = totalAmountToTake;
|
|
|
|
totalAmountToTake = 0;
|
|
}
|
|
|
|
duplicatedInventoryInfo.isEquipped = false;
|
|
|
|
duplicatedInventoryInfo.quickAccessSlotIndex = -1;
|
|
|
|
duplicatedInventoryInfo.projectilesInMagazine = -1;
|
|
|
|
duplicatedInventoryInfo.button = null;
|
|
|
|
//if (i == 0) {
|
|
// currentInventoryList.Insert (i, duplicatedInventoryInfo);
|
|
//} else {
|
|
// currentInventoryList.Insert (i - 1, duplicatedInventoryInfo);
|
|
//}
|
|
|
|
currentInventoryList.Add (duplicatedInventoryInfo);
|
|
|
|
loopCount++;
|
|
|
|
if (loopCount > 100) {
|
|
allAmountTaken = true;
|
|
}
|
|
|
|
if (totalAmountToTake <= 0) {
|
|
allAmountTaken = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void addObjectToUse ()
|
|
{
|
|
numberOfObjectsToUse++;
|
|
|
|
if (numberOfObjectsToUse > currentInventoryObject.amount) {
|
|
numberOfObjectsToUse = currentInventoryObject.amount;
|
|
}
|
|
|
|
currentAmountToMove = numberOfObjectsToUse;
|
|
|
|
setNumberOfObjectsToUseText (numberOfObjectsToUse);
|
|
}
|
|
|
|
public void removeObjectToUse ()
|
|
{
|
|
numberOfObjectsToUse--;
|
|
|
|
if (numberOfObjectsToUse < 1) {
|
|
numberOfObjectsToUse = 1;
|
|
}
|
|
|
|
currentAmountToMove = numberOfObjectsToUse;
|
|
|
|
setNumberOfObjectsToUseText (numberOfObjectsToUse);
|
|
}
|
|
|
|
public void startToAddObjectToUse ()
|
|
{
|
|
addingObjectToUse = true;
|
|
|
|
lastTimeConfigureNumberOfObjects = Time.time;
|
|
}
|
|
|
|
public void stopToAddObjectToUse ()
|
|
{
|
|
addingObjectToUse = false;
|
|
|
|
lastTimeAddObjectToUse = 0;
|
|
|
|
useFasterNumberObjectsToUseRateActive = false;
|
|
}
|
|
|
|
public void startToRemoveObjectToUse ()
|
|
{
|
|
removinvObjectToUse = true;
|
|
|
|
lastTimeConfigureNumberOfObjects = Time.time;
|
|
}
|
|
|
|
public void stopToRemoveObjectToUse ()
|
|
{
|
|
removinvObjectToUse = false;
|
|
|
|
lastTimeRemoveObjectToUse = 0;
|
|
|
|
useFasterNumberObjectsToUseRateActive = false;
|
|
}
|
|
|
|
public void enableNumberOfObjectsToUseMenu (RectTransform menuPosition)
|
|
{
|
|
numberOfElementsWindow.SetActive (true);
|
|
|
|
numberOfObjectsToUse = 1;
|
|
|
|
currentAmountToMove = numberOfObjectsToUse;
|
|
|
|
setNumberOfObjectsToUseText (numberOfObjectsToUse);
|
|
|
|
settingAmountObjectsToMove = true;
|
|
}
|
|
|
|
public void resetAndDisableNumberOfObjectsToUseMenu ()
|
|
{
|
|
disableNumberOfObjectsToUseMenu ();
|
|
|
|
resetNumberOfObjectsToUse ();
|
|
}
|
|
|
|
public void disableNumberOfObjectsToUseMenu ()
|
|
{
|
|
numberOfObjectsToUse = 1;
|
|
|
|
numberOfElementsWindow.SetActive (false);
|
|
}
|
|
|
|
public void resetNumberOfObjectsToUse ()
|
|
{
|
|
numberOfObjectsToUse = 1;
|
|
|
|
setNumberOfObjectsToUseText (numberOfObjectsToUse);
|
|
}
|
|
|
|
public void setNumberOfObjectsToUseText (int amount)
|
|
{
|
|
numberOfObjectsToUseText.text = amount.ToString ();
|
|
}
|
|
|
|
public void resetScroll (Scrollbar scrollBarToReset)
|
|
{
|
|
StartCoroutine (resetScrollCoroutine (scrollBarToReset));
|
|
}
|
|
|
|
IEnumerator resetScrollCoroutine (Scrollbar scrollBarToReset)
|
|
{
|
|
yield return new WaitForEndOfFrame ();
|
|
yield return new WaitForEndOfFrame ();
|
|
|
|
scrollBarToReset.value = 1;
|
|
}
|
|
|
|
public void resetBankInventoryRectTransform ()
|
|
{
|
|
StartCoroutine (resetBankInventoryRectTransformCoroutine ());
|
|
}
|
|
|
|
IEnumerator resetBankInventoryRectTransformCoroutine ()
|
|
{
|
|
LayoutRebuilder.ForceRebuildLayoutImmediate (bankInventorySlotsContent.GetComponent<RectTransform> ());
|
|
|
|
yield return new WaitForEndOfFrame ();
|
|
yield return new WaitForEndOfFrame ();
|
|
|
|
yield return new WaitForEndOfFrame ();
|
|
yield return new WaitForEndOfFrame ();
|
|
|
|
LayoutRebuilder.ForceRebuildLayoutImmediate (bankInventoryScrollbar.GetComponent<RectTransform> ());
|
|
}
|
|
|
|
public void updateFullInventorySlots (List<inventoryInfo> currentInventoryList, List<inventoryMenuIconElement> currentIconElementList,
|
|
bool checkInventorySlotAmount)
|
|
{
|
|
int currentIconElementListCount = currentIconElementList.Count;
|
|
|
|
for (int i = 0; i < currentIconElementListCount; i++) {
|
|
if (currentIconElementList [i].button != null && currentIconElementList [i].button.gameObject.activeSelf) {
|
|
currentIconElementList [i].button.gameObject.SetActive (false);
|
|
}
|
|
}
|
|
|
|
int currentInventoryListCount = currentInventoryList.Count;
|
|
|
|
for (int i = 0; i < currentInventoryListCount; i++) {
|
|
if (i < currentIconElementListCount) {
|
|
inventoryInfo currentInventoryInfo = currentInventoryList [i];
|
|
currentInventoryInfo.menuIconElement = currentIconElementList [i];
|
|
currentInventoryInfo.button = currentIconElementList [i].button;
|
|
|
|
if (!currentInventoryInfo.button.gameObject.activeSelf) {
|
|
currentInventoryInfo.button.gameObject.SetActive (true);
|
|
}
|
|
|
|
string currentInventoryInfoName = currentInventoryInfo.Name;
|
|
|
|
if (gameLanguageSelector.isCheckLanguageActive ()) {
|
|
currentInventoryInfoName = inventoryLocalizationManager.GetLocalizedValue (currentInventoryInfoName);
|
|
}
|
|
|
|
currentInventoryInfo.menuIconElement.iconName.text = currentInventoryInfoName;
|
|
|
|
currentInventoryInfo.menuIconElement.icon.texture = currentInventoryInfo.icon;
|
|
|
|
currentInventoryInfo.menuIconElement.amount.text = currentInventoryInfo.amount.ToString ();
|
|
|
|
currentInventoryInfo.button.name = "Inventory Object-" + (i + 1);
|
|
|
|
if (checkInventorySlotAmount) {
|
|
bool slotIsActive = currentInventoryInfo.amount > 0;
|
|
|
|
if (currentInventoryInfo.menuIconElement.activeSlotContent != null) {
|
|
currentInventoryInfo.menuIconElement.activeSlotContent.SetActive (slotIsActive);
|
|
}
|
|
|
|
if (currentInventoryInfo.menuIconElement.emptySlotContent != null) {
|
|
currentInventoryInfo.menuIconElement.emptySlotContent.SetActive (!slotIsActive);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setMenuIconElementPressedState (bool state)
|
|
{
|
|
if (currentInventoryObject != null) {
|
|
if (currentInventoryObject.menuIconElement != null) {
|
|
currentInventoryObject.menuIconElement.pressedIcon.SetActive (state);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void removeButton (List<inventoryInfo> currentInventoryList, List<inventoryMenuIconElement> currentIconElementList,
|
|
bool removeElementFromInventoryList)
|
|
{
|
|
|
|
for (int i = currentInventoryList.Count - 1; i >= 0; i--) {
|
|
if (currentInventoryList [i].amount == 0) {
|
|
currentInventoryList.RemoveAt (i);
|
|
}
|
|
}
|
|
|
|
if (!removeElementFromInventoryList) {
|
|
if (showEmptySlotsOnUseMaxInventoryBankSlotsAmount) {
|
|
int extraEmptyInventorySlots = Math.Abs (currentInventoryList.Count - maxInventoryBankSlotsAmount);
|
|
|
|
for (int i = 0; i < extraEmptyInventorySlots; i++) {
|
|
currentInventoryList.Add (new inventoryInfo ());
|
|
}
|
|
}
|
|
}
|
|
|
|
enableRotation = false;
|
|
|
|
destroyObjectInCamera ();
|
|
|
|
setMenuIconElementPressedState (false);
|
|
|
|
currentInventoryObject = null;
|
|
|
|
currentInventoryObjectManager = null;
|
|
}
|
|
|
|
public void resetDragDropElements ()
|
|
{
|
|
if (!resetDragDropElementsEnabled) {
|
|
return;
|
|
}
|
|
|
|
slotFound = null;
|
|
|
|
draggedFromPlayerInventoryList = false;
|
|
|
|
draggedFromBankInventoryList = false;
|
|
|
|
droppedInBankInventoryList = false;
|
|
|
|
droppedInPlayerInventoryList = false;
|
|
|
|
slotToMoveFound = false;
|
|
|
|
currentSlotFoundInventoryObject = null;
|
|
|
|
currentSlotToMoveInventoryObject = null;
|
|
|
|
settingAmountObjectsToMove = false;
|
|
|
|
lastTimeSlotToMoveFound = 0;
|
|
|
|
resetAndDisableNumberOfObjectsToUseMenu ();
|
|
}
|
|
|
|
public void checkIfObjecToMoveAlreadyInBankList ()
|
|
{
|
|
currentObjectAlreadyInBankList = false;
|
|
|
|
if (currentSlotToMoveInventoryObject != null) {
|
|
for (int j = 0; j < currentBankInventoryList.Count; j++) {
|
|
if (!currentObjectAlreadyInBankList && currentBankInventoryList [j].Name.Equals (currentSlotToMoveInventoryObject.Name)) {
|
|
currentObjectAlreadyInBankList = true;
|
|
currentBankInventoryListIndex = j;
|
|
|
|
if (showDebugPrint) {
|
|
print ("Current Object Already In Bank List, adding amount to that object");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void confirmMoveObjects ()
|
|
{
|
|
if (draggedFromPlayerInventoryList) {
|
|
|
|
if ((dragAndDropIcons && droppedInBankInventoryList) || !dragAndDropIcons) {
|
|
|
|
checkIfObjecToMoveAlreadyInBankList ();
|
|
|
|
moveObjectsToBankInventory ();
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (draggedFromBankInventoryList) {
|
|
|
|
if ((dragAndDropIcons && droppedInPlayerInventoryList) || !dragAndDropIcons) {
|
|
moveObjectsToPlayerInventory ();
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void confirmMoveAllObjects ()
|
|
{
|
|
currentAmountToMove = currentInventoryObject.amount;
|
|
|
|
confirmMoveObjects ();
|
|
}
|
|
|
|
public void confirmMoveFullInventoryBankToPlayerInventory ()
|
|
{
|
|
pauseUpdateUIOnMoveFullInventoryBankToPlayerInventoryActive = true;
|
|
|
|
for (int i = currentBankInventoryList.Count - 1; i >= 0; i--) {
|
|
currentSlotToMoveInventoryObject = currentBankInventoryList [i];
|
|
|
|
if (currentSlotToMoveInventoryObject.amount > 0) {
|
|
bool canMoveObjectResult = true;
|
|
|
|
if (playerInventoryManager.isInventoryFull ()) {
|
|
canMoveObjectResult = false;
|
|
}
|
|
|
|
if (playerInventoryManager.getNumberOfFreeSlots () <= 0) {
|
|
canMoveObjectResult = false;
|
|
}
|
|
|
|
if (!canMoveObjectResult) {
|
|
if (playerInventoryManager.checkIfObjectCanBeStored (currentSlotToMoveInventoryObject.inventoryGameObject,
|
|
currentSlotToMoveInventoryObject.amount)) {
|
|
canMoveObjectResult = true;
|
|
}
|
|
}
|
|
|
|
if (canMoveObjectResult) {
|
|
currentAmountToMove = currentSlotToMoveInventoryObject.amount;
|
|
|
|
moveObjectsToPlayerInventory ();
|
|
}
|
|
}
|
|
}
|
|
|
|
pauseUpdateUIOnMoveFullInventoryBankToPlayerInventoryActive = false;
|
|
|
|
updateInventoryInfoOnMoveObjectsToPlayerInventory ();
|
|
|
|
cancelMoveObjects ();
|
|
}
|
|
|
|
bool pauseUpdateUIOnMoveFullInventoryBankToPlayerInventoryActive;
|
|
|
|
bool pauseUpdateUIOnMoveFullPlayerInventoryToBankInventoryActive;
|
|
|
|
public void confirmMoveFullPlayerInventoryToBankInventory ()
|
|
{
|
|
if (!canDropObjectsToInventoryBank) {
|
|
return;
|
|
}
|
|
|
|
pauseUpdateUIOnMoveFullPlayerInventoryToBankInventoryActive = true;
|
|
|
|
for (int i = playerInventoryList.Count - 1; i >= 0; i--) {
|
|
currentSlotToMoveInventoryObject = playerInventoryList [i];
|
|
|
|
if (currentSlotToMoveInventoryObject.amount > 0) {
|
|
bool canMoveObjectResult = true;
|
|
|
|
if (useMaxInventoryBankSlotsAmount) {
|
|
if (currentBankInventoryList.Count >= maxInventoryBankSlotsAmount) {
|
|
canMoveObjectResult = false;
|
|
}
|
|
|
|
if (checkIfEmptySlotsOnInventoryList (currentBankInventoryList)) {
|
|
canMoveObjectResult = true;
|
|
} else {
|
|
canMoveObjectResult = false;
|
|
}
|
|
}
|
|
|
|
if (canMoveObjectResult) {
|
|
currentAmountToMove = currentSlotToMoveInventoryObject.amount;
|
|
|
|
objectToMoveIndex = i;
|
|
|
|
checkIfObjecToMoveAlreadyInBankList ();
|
|
|
|
moveObjectsToBankInventory ();
|
|
}
|
|
}
|
|
}
|
|
|
|
pauseUpdateUIOnMoveFullPlayerInventoryToBankInventoryActive = false;
|
|
|
|
updateInventoryInfoOnMoveObjectsToBankInventory ();
|
|
|
|
cancelMoveObjects ();
|
|
}
|
|
|
|
public void cancelMoveObjects ()
|
|
{
|
|
resetDragDropElements ();
|
|
|
|
resetAndDisableNumberOfObjectsToUseMenu ();
|
|
}
|
|
|
|
//Inventory bank UI management
|
|
public void getPressedButton (Button buttonObj)
|
|
{
|
|
int inventoryObjectIndex = -1;
|
|
|
|
if (draggedFromPlayerInventoryList) {
|
|
for (int i = 0; i < playerInventoryList.Count; i++) {
|
|
if (playerInventoryList [i].button == buttonObj) {
|
|
inventoryObjectIndex = i;
|
|
}
|
|
}
|
|
} else {
|
|
for (int i = 0; i < currentBankInventoryList.Count; i++) {
|
|
if (currentBankInventoryList [i].button == buttonObj) {
|
|
inventoryObjectIndex = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentInventoryObject != null) {
|
|
if (((draggedFromPlayerInventoryList && currentInventoryObject == playerInventoryList [inventoryObjectIndex]) ||
|
|
(!draggedFromPlayerInventoryList && currentInventoryObject == currentBankInventoryList [inventoryObjectIndex])) &&
|
|
currentInventoryObject.menuIconElement.pressedIcon.activeSelf) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
setObjectInfo (inventoryObjectIndex, draggedFromPlayerInventoryList);
|
|
|
|
float currentCameraFov = originalFov;
|
|
|
|
if (currentInventoryObjectManager) {
|
|
if (currentInventoryObjectManager.useZoomRange) {
|
|
currentCameraFov = currentInventoryObjectManager.initialZoom;
|
|
}
|
|
}
|
|
|
|
if (inventoryCamera.fieldOfView != currentCameraFov) {
|
|
checkResetCameraFov (currentCameraFov);
|
|
}
|
|
}
|
|
|
|
public void setObjectInfo (int index, bool isPlayerInventoryList)
|
|
{
|
|
resetAndDisableNumberOfObjectsToUseMenu ();
|
|
|
|
setMenuIconElementPressedState (false);
|
|
|
|
if (isPlayerInventoryList) {
|
|
currentInventoryObject = playerInventoryList [index];
|
|
} else {
|
|
currentInventoryObject = currentBankInventoryList [index];
|
|
}
|
|
setMenuIconElementPressedState (true);
|
|
|
|
GameObject currentInventoryObjectPrefab = currentInventoryObject.inventoryGameObject;
|
|
|
|
checkGetMainInventoryManager ();
|
|
|
|
for (int i = 0; i < mainInventoryListManager.inventoryList.Count; i++) {
|
|
if (mainInventoryListManager.inventoryList [i].inventoryGameObject == currentInventoryObject.inventoryGameObject) {
|
|
currentInventoryObjectPrefab = mainInventoryListManager.inventoryList [i].inventoryObjectPrefab;
|
|
}
|
|
}
|
|
|
|
currentInventoryObjectManager = currentInventoryObjectPrefab.GetComponentInChildren<inventoryObject> ();
|
|
|
|
inventoryMenuRenderTexture.enabled = true;
|
|
|
|
destroyObjectInCamera ();
|
|
|
|
if (currentInventoryObject.inventoryGameObject != null) {
|
|
|
|
objectInCamera = (GameObject)Instantiate (currentInventoryObject.inventoryGameObject, lookObjectsPosition.position, Quaternion.identity, lookObjectsPosition);
|
|
}
|
|
}
|
|
|
|
public void checkInventoryObjectSlotsInput ()
|
|
{
|
|
//check the mouse position in the screen if we are in the editor, or the finger position in a touch device
|
|
int touchCount = Input.touchCount;
|
|
|
|
if (!touchPlatform) {
|
|
touchCount++;
|
|
}
|
|
|
|
for (int i = 0; i < touchCount; i++) {
|
|
if (!touchPlatform) {
|
|
currentTouch = touchJoystick.convertMouseIntoFinger ();
|
|
} else {
|
|
currentTouch = Input.GetTouch (i);
|
|
}
|
|
|
|
if (currentTouch.phase == TouchPhase.Began) {
|
|
touching = true;
|
|
|
|
draggingSlotActive = false;
|
|
|
|
lastTimeTouched = Time.time;
|
|
|
|
captureRaycastResults.Clear ();
|
|
|
|
PointerEventData p = new PointerEventData (EventSystem.current);
|
|
p.position = currentTouch.position;
|
|
p.clickCount = i;
|
|
p.dragging = false;
|
|
|
|
EventSystem.current.RaycastAll (p, captureRaycastResults);
|
|
|
|
if (slotToMoveFound) {
|
|
bool pressingOnAnyInventoryGridResult = false;
|
|
|
|
foreach (RaycastResult r in captureRaycastResults) {
|
|
if (r.gameObject == playerInventorySlots || r.gameObject == bankInventorySlots) {
|
|
pressingOnAnyInventoryGridResult = true;
|
|
}
|
|
}
|
|
|
|
if (!pressingOnAnyInventoryGridResult) {
|
|
print ("ignoring press");
|
|
|
|
touching = false;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
foreach (RaycastResult r in captureRaycastResults) {
|
|
|
|
bool checkSlotsResult = true;
|
|
|
|
if (slotToMoveFound) {
|
|
if (lastTimeSlotToMoveFound == 0 || Time.time < lastTimeSlotToMoveFound + 0.5f) {
|
|
checkSlotsResult = false;
|
|
} else {
|
|
if (draggingSlotActive) {
|
|
checkSlotsResult = false;
|
|
}
|
|
}
|
|
|
|
if (checkSlotsResult) {
|
|
resetDragDropElementsEnabled = true;
|
|
|
|
cancelMoveObjects ();
|
|
|
|
print ("reset");
|
|
}
|
|
}
|
|
|
|
if (checkSlotsResult) {
|
|
inventoryMenuIconElement currentInventoryMenuIconElement = r.gameObject.GetComponent<inventoryMenuIconElement> ();
|
|
|
|
if (currentInventoryMenuIconElement) {
|
|
|
|
bool objectFound = false;
|
|
|
|
for (int j = 0; j < playerInventoryList.Count; j++) {
|
|
if (!objectFound && playerInventoryList [j].button == currentInventoryMenuIconElement.button) {
|
|
|
|
if (!canDropObjectsToInventoryBank) {
|
|
return;
|
|
}
|
|
|
|
if (playerInventoryList [j].amount > 0) {
|
|
currentSlotToMoveInventoryObject = playerInventoryList [j];
|
|
|
|
draggedFromPlayerInventoryList = true;
|
|
|
|
slotToMoveFound = true;
|
|
|
|
lastTimeSlotToMoveFound = Time.time;
|
|
|
|
objectToMoveIndex = j;
|
|
|
|
if (showDebugPrint) {
|
|
print ("dragged from player inventory list " + j);
|
|
}
|
|
|
|
objectFound = true;
|
|
|
|
getPressedButton (currentInventoryMenuIconElement.button);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!draggedFromPlayerInventoryList) {
|
|
|
|
objectFound = false;
|
|
|
|
for (int j = 0; j < currentBankInventoryList.Count; j++) {
|
|
if (!objectFound && currentBankInventoryList [j].button == currentInventoryMenuIconElement.button) {
|
|
if (currentBankInventoryList [j].amount > 0) {
|
|
currentSlotToMoveInventoryObject = currentBankInventoryList [j];
|
|
|
|
draggedFromBankInventoryList = true;
|
|
|
|
slotToMoveFound = true;
|
|
|
|
lastTimeSlotToMoveFound = Time.time;
|
|
|
|
objectToMoveIndex = j;
|
|
|
|
if (showDebugPrint) {
|
|
print ("dragged from bank inventory list " + j);
|
|
}
|
|
|
|
objectFound = true;
|
|
|
|
getPressedButton (currentInventoryMenuIconElement.button);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (slotToMoveFound && dragAndDropIcons) {
|
|
slotToMove.GetComponentInChildren<RawImage> ().texture = currentInventoryMenuIconElement.icon.texture;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (touching && !dragAndDropIcons && slotToMoveFound) {
|
|
touching = false;
|
|
|
|
draggingSlotActive = false;
|
|
|
|
checkDroppedObject ();
|
|
|
|
return;
|
|
}
|
|
|
|
if ((currentTouch.phase == TouchPhase.Stationary || currentTouch.phase == TouchPhase.Moved)) {
|
|
if (slotToMoveFound && dragAndDropIcons) {
|
|
if (touching && Time.time > lastTimeTouched + timeToDrag) {
|
|
if (!slotToMove.activeSelf) {
|
|
slotToMove.SetActive (true);
|
|
}
|
|
|
|
slotToMove.GetComponent<RectTransform> ().position = new Vector2 (currentTouch.position.x, currentTouch.position.y);
|
|
|
|
draggingSlotActive = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//if the mouse/finger press is released, then
|
|
if (currentTouch.phase == TouchPhase.Ended && touching) {
|
|
|
|
touching = false;
|
|
|
|
if (draggingSlotActive) {
|
|
draggingSlotActive = false;
|
|
|
|
if (slotToMoveFound) {
|
|
//get the elements in the position where the player released the slot element
|
|
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) {
|
|
if (r.gameObject != slotToMove) {
|
|
if (r.gameObject.GetComponent<inventoryMenuIconElement> ()) {
|
|
slotFound = r.gameObject;
|
|
} else if (r.gameObject == playerInventorySlots) {
|
|
droppedInPlayerInventoryList = true;
|
|
} else if (r.gameObject == bankInventorySlots) {
|
|
droppedInBankInventoryList = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
checkDroppedObject ();
|
|
}
|
|
} else {
|
|
if (useNumberOfElementsWhenIconNotMoved) {
|
|
if (currentSlotToMoveInventoryObject != null && currentSlotToMoveInventoryObject.button != null) {
|
|
enableNumberOfElementsOnPressUp ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkDroppedObject ()
|
|
{
|
|
replacingObjectsActive = false;
|
|
|
|
//an icon has been dropped on top of another icon from both inventory list
|
|
if (slotFound != null) {
|
|
bool droppedCorreclty = true;
|
|
bool currentSlotDroppedFoundOnList = false;
|
|
|
|
inventoryMenuIconElement slotFoundInventoryMenuIconElement = slotFound.GetComponent<inventoryMenuIconElement> ();
|
|
|
|
for (int j = 0; j < playerInventoryList.Count; j++) {
|
|
if (playerInventoryList [j].button == slotFoundInventoryMenuIconElement.button) {
|
|
currentSlotFoundInventoryObject = playerInventoryList [j];
|
|
currentSlotDroppedFoundOnList = true;
|
|
objectFoundIndex = j;
|
|
}
|
|
}
|
|
|
|
if (!currentSlotDroppedFoundOnList) {
|
|
for (int j = 0; j < currentBankInventoryList.Count; j++) {
|
|
if (currentBankInventoryList [j].button == slotFoundInventoryMenuIconElement.button) {
|
|
currentSlotFoundInventoryObject = currentBankInventoryList [j];
|
|
currentSlotDroppedFoundOnList = true;
|
|
objectFoundIndex = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentSlotDroppedFoundOnList) {
|
|
if (((draggedFromBankInventoryList && droppedInPlayerInventoryList) || (draggedFromPlayerInventoryList && droppedInBankInventoryList))) {
|
|
if (showDebugPrint) {
|
|
print (currentSlotToMoveInventoryObject.Name + " dropped on top of " + currentSlotFoundInventoryObject.Name);
|
|
}
|
|
|
|
if (droppedInPlayerInventoryList) {
|
|
if (showDebugPrint) {
|
|
print ("dropped correctly to player inventory");
|
|
}
|
|
|
|
resetDragDropElementsEnabled = false;
|
|
|
|
inventoryInfo auxInventoryInfo = currentSlotToMoveInventoryObject;
|
|
int auxObjectToMoveIndex = objectToMoveIndex;
|
|
|
|
//move the object dropped to players's inventory
|
|
currentSlotToMoveInventoryObject = currentSlotFoundInventoryObject;
|
|
objectToMoveIndex = objectFoundIndex;
|
|
|
|
if (canDropObjectsToInventoryBank) {
|
|
replacingObjectsActive = true;
|
|
|
|
dragToBankInventory ();
|
|
|
|
replacingObjectsActive = false;
|
|
}
|
|
|
|
objectToMoveIndex = auxObjectToMoveIndex;
|
|
|
|
currentSlotToMoveInventoryObject = auxInventoryInfo;
|
|
|
|
if (showDebugPrint) {
|
|
print (currentSlotToMoveInventoryObject.Name + " found on player's inventory");
|
|
}
|
|
|
|
resetDragDropElementsEnabled = true;
|
|
|
|
dragToPlayerInventory ();
|
|
|
|
} else if (droppedInBankInventoryList) {
|
|
if (showDebugPrint) {
|
|
print ("dropped correctly to bank inventory");
|
|
}
|
|
|
|
resetDragDropElementsEnabled = false;
|
|
//move the object dropped to bank inventory
|
|
|
|
replacingObjectsActive = true;
|
|
|
|
dragToBankInventory ();
|
|
|
|
replacingObjectsActive = false;
|
|
|
|
objectToMoveIndex = objectFoundIndex;
|
|
|
|
currentSlotToMoveInventoryObject = currentBankInventoryList [objectToMoveIndex];
|
|
|
|
if (showDebugPrint) {
|
|
print (currentSlotToMoveInventoryObject.Name + " found on bank");
|
|
}
|
|
|
|
resetDragDropElementsEnabled = true;
|
|
|
|
dragToPlayerInventory ();
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("dropped into the same dragged list");
|
|
}
|
|
|
|
droppedCorreclty = false;
|
|
|
|
if (useNumberOfElementsWhenIconNotMoved) {
|
|
enableNumberOfElementsOnPressUp ();
|
|
droppedCorreclty = true;
|
|
}
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("dropped outside the list");
|
|
}
|
|
|
|
droppedCorreclty = false;
|
|
}
|
|
|
|
slotToMove.SetActive (false);
|
|
|
|
if (!droppedCorreclty) {
|
|
resetDragDropElements ();
|
|
}
|
|
}
|
|
|
|
//the icon is dropped on top or bottom of any of the inventory list
|
|
else {
|
|
bool droppedCorreclty = true;
|
|
|
|
//if the object to move has been dragged and dropped from one list to another correctly, then
|
|
if (((draggedFromBankInventoryList && droppedInPlayerInventoryList) || (draggedFromPlayerInventoryList && droppedInBankInventoryList))) {
|
|
//dropping object from bank to player's inventory
|
|
if (droppedInPlayerInventoryList) {
|
|
dragToPlayerInventory ();
|
|
} else if (droppedInBankInventoryList) {
|
|
//dropping object from player's inventory to bank
|
|
bool canDropToInventoryResult = true;
|
|
|
|
if (useMaxInventoryBankSlotsAmount) {
|
|
if (showEmptySlotsOnUseMaxInventoryBankSlotsAmount) {
|
|
if (!checkIfEmptySlotsOnInventoryList (currentBankInventoryList)) {
|
|
canDropToInventoryResult = false;
|
|
}
|
|
} else {
|
|
if (bankIconElementList.Count >= maxInventoryBankSlotsAmount) {
|
|
canDropToInventoryResult = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (canDropToInventoryResult) {
|
|
dragToBankInventory ();
|
|
} else {
|
|
playerInventoryManager.showObjectMessage (inventoryBankFullMessage, 5);
|
|
|
|
resetDragDropElements ();
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("not dropped correctly");
|
|
}
|
|
|
|
droppedCorreclty = false;
|
|
}
|
|
} else {
|
|
if (dragAndDropIcons) {
|
|
if (showDebugPrint) {
|
|
print ("dropped into the same dragged list or outside of the list");
|
|
}
|
|
|
|
droppedCorreclty = false;
|
|
|
|
if (useNumberOfElementsOnPressUp) {
|
|
enableNumberOfElementsOnPressUp ();
|
|
|
|
droppedCorreclty = true;
|
|
}
|
|
|
|
} else {
|
|
//if the drag and drop function is not being used, check if the pressed icon is in player or bank inventory to move the object
|
|
if (draggedFromBankInventoryList) {
|
|
dragToPlayerInventory ();
|
|
} else if (draggedFromPlayerInventoryList) {
|
|
bool canDropToInventoryResult = true;
|
|
|
|
if (useMaxInventoryBankSlotsAmount) {
|
|
if (showEmptySlotsOnUseMaxInventoryBankSlotsAmount) {
|
|
if (!checkIfEmptySlotsOnInventoryList (currentBankInventoryList)) {
|
|
canDropToInventoryResult = false;
|
|
}
|
|
} else {
|
|
if (bankIconElementList.Count >= maxInventoryBankSlotsAmount) {
|
|
canDropToInventoryResult = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (canDropToInventoryResult) {
|
|
dragToBankInventory ();
|
|
} else {
|
|
playerInventoryManager.showObjectMessage (inventoryBankFullMessage, 5);
|
|
|
|
resetDragDropElements ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
slotToMove.SetActive (false);
|
|
|
|
if (!droppedCorreclty) {
|
|
resetDragDropElements ();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool checkIfEmptySlotsOnInventoryList (List<inventoryInfo> currentInventoryList)
|
|
{
|
|
for (int j = 0; j < currentInventoryList.Count; j++) {
|
|
if (currentInventoryList [j].amount <= 0) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void dragToPlayerInventory ()
|
|
{
|
|
if (showDebugPrint) {
|
|
print ("dropped correctly to player inventory");
|
|
|
|
print (currentSlotToMoveInventoryObject.Name + " dropped correctly to player inventory");
|
|
}
|
|
|
|
currentAmountToMove = currentSlotToMoveInventoryObject.amount;
|
|
|
|
if (dropFullObjectsAmount) {
|
|
moveObjectsToPlayerInventory ();
|
|
} else {
|
|
enableNumberOfObjectsToUseMenu (currentSlotToMoveInventoryObject.button.GetComponent<RectTransform> ());
|
|
}
|
|
}
|
|
|
|
public void dragToBankInventory ()
|
|
{
|
|
if (showDebugPrint) {
|
|
print ("dropped correctly to bank inventory");
|
|
}
|
|
|
|
currentObjectAlreadyInBankList = false;
|
|
currentBankInventoryListIndex = -1;
|
|
|
|
for (int j = 0; j < currentBankInventoryList.Count; j++) {
|
|
if (!currentObjectAlreadyInBankList && currentBankInventoryList [j].Name.Equals (currentSlotToMoveInventoryObject.Name)) {
|
|
currentObjectAlreadyInBankList = true;
|
|
currentBankInventoryListIndex = j;
|
|
}
|
|
}
|
|
|
|
currentAmountToMove = currentSlotToMoveInventoryObject.amount;
|
|
|
|
if (dropFullObjectsAmount) {
|
|
moveObjectsToBankInventory ();
|
|
} else {
|
|
enableNumberOfObjectsToUseMenu (currentSlotToMoveInventoryObject.button.GetComponent<RectTransform> ());
|
|
}
|
|
}
|
|
|
|
public void moveObjectsToBankInventory ()
|
|
{
|
|
if (currentObjectAlreadyInBankList) {
|
|
currentBankInventoryList [currentBankInventoryListIndex].amount += currentAmountToMove;
|
|
|
|
if (showDebugPrint) {
|
|
print ("combine objects amount + " + currentAmountToMove);
|
|
}
|
|
} else {
|
|
currentSlotToMoveInventoryObject.amount = currentAmountToMove;
|
|
|
|
if (showEmptySlotsOnUseMaxInventoryBankSlotsAmount) {
|
|
if (replacingObjectsActive) {
|
|
currentBankInventoryList.Add (new inventoryInfo (currentSlotToMoveInventoryObject));
|
|
} else {
|
|
int indexToInsert = -1;
|
|
|
|
for (int i = 0; i < currentBankInventoryList.Count; i++) {
|
|
if (indexToInsert == -1) {
|
|
if (currentBankInventoryList [i].amount <= 0) {
|
|
indexToInsert = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (indexToInsert > -1) {
|
|
currentBankInventoryList.Insert (indexToInsert, new inventoryInfo (currentSlotToMoveInventoryObject));
|
|
|
|
currentBankInventoryList.RemoveAt (indexToInsert + 1);
|
|
}
|
|
}
|
|
} else {
|
|
currentBankInventoryList.Add (new inventoryInfo (currentSlotToMoveInventoryObject));
|
|
|
|
int lastAddedObjectIndex = currentBankInventoryList.Count;
|
|
|
|
createInventoryIcon (currentBankInventoryList [lastAddedObjectIndex - 1], lastAddedObjectIndex - 1, bankInventorySlot,
|
|
bankInventorySlotsContent, bankIconElementList);
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("new object added +" + currentAmountToMove);
|
|
}
|
|
}
|
|
|
|
playerInventoryManager.moveObjectToBank (objectToMoveIndex, currentAmountToMove);
|
|
|
|
if (pauseUpdateUIOnMoveFullPlayerInventoryToBankInventoryActive) {
|
|
return;
|
|
}
|
|
|
|
updateInventoryInfoOnMoveObjectsToBankInventory ();
|
|
}
|
|
|
|
void updateInventoryInfoOnMoveObjectsToBankInventory ()
|
|
{
|
|
getCurrentPlayerInventoryList ();
|
|
|
|
checkMaximumAmountPerSlotOnInventoryList (currentBankInventoryList);
|
|
|
|
checkIfAddInventoryIconOnBankInventoryList ();
|
|
|
|
updateFullInventorySlots (playerInventoryList, playerIconElementList, true);
|
|
|
|
updateFullInventorySlots (currentBankInventoryList, bankIconElementList, false || showEmptySlotsOnUseMaxInventoryBankSlotsAmount);
|
|
|
|
resetDragDropElements ();
|
|
|
|
resetBankInventoryRectTransform ();
|
|
}
|
|
|
|
void checkIfAddInventoryIconOnBankInventoryList ()
|
|
{
|
|
int currentInventoryListCount = currentBankInventoryList.Count;
|
|
|
|
for (int i = 0; i < currentInventoryListCount; i++) {
|
|
inventoryInfo currentInventoryInfo = currentBankInventoryList [i];
|
|
|
|
if (currentInventoryInfo.button == null) {
|
|
createInventoryIcon (currentInventoryInfo, i, bankInventorySlot,
|
|
bankInventorySlotsContent, bankIconElementList);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void moveObjectsToPlayerInventory ()
|
|
{
|
|
int currentSlotToMoveAmount = currentSlotToMoveInventoryObject.amount;
|
|
currentSlotToMoveInventoryObject.amount = currentAmountToMove;
|
|
|
|
if (currentSlotToMoveAmount > 0) {
|
|
if (!playerInventoryManager.isInventoryFull ()) {
|
|
int inventoryAmountPicked = playerInventoryManager.tryToPickUpObject (currentSlotToMoveInventoryObject);
|
|
|
|
if (showDebugPrint) {
|
|
print ("amount taken " + inventoryAmountPicked);
|
|
}
|
|
|
|
if (inventoryAmountPicked > 0) {
|
|
currentSlotToMoveInventoryObject.amount = currentSlotToMoveAmount - inventoryAmountPicked;
|
|
} else {
|
|
playerInventoryManager.showInventoryFullMessage ();
|
|
}
|
|
} else {
|
|
playerInventoryManager.showInventoryFullMessage ();
|
|
}
|
|
}
|
|
|
|
if (pauseUpdateUIOnMoveFullInventoryBankToPlayerInventoryActive) {
|
|
return;
|
|
}
|
|
|
|
updateInventoryInfoOnMoveObjectsToPlayerInventory ();
|
|
}
|
|
|
|
void updateInventoryInfoOnMoveObjectsToPlayerInventory ()
|
|
{
|
|
getCurrentPlayerInventoryList ();
|
|
|
|
checkMaximumAmountPerSlotOnInventoryList (currentBankInventoryList);
|
|
|
|
removeButton (currentBankInventoryList, bankIconElementList, !showEmptySlotsOnUseMaxInventoryBankSlotsAmount);
|
|
|
|
updateFullInventorySlots (playerInventoryList, playerIconElementList, true);
|
|
|
|
updateFullInventorySlots (currentBankInventoryList, bankIconElementList, false || showEmptySlotsOnUseMaxInventoryBankSlotsAmount);
|
|
|
|
LayoutRebuilder.ForceRebuildLayoutImmediate (bankInventorySlotsContent.GetComponent<RectTransform> ());
|
|
|
|
resetDragDropElements ();
|
|
|
|
resetBankInventoryRectTransform ();
|
|
}
|
|
} |