381 lines
12 KiB
C#
381 lines
12 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using TMPro;
|
|
using UnityEngine.EventSystems;
|
|
|
|
// TODO: Expand for other measurement systems later
|
|
|
|
|
|
namespace SimpleInventorySystem
|
|
{
|
|
public enum Orientation { Portrait, Landscape };
|
|
|
|
[Serializable]
|
|
public struct Size
|
|
{
|
|
public int Width;
|
|
public int Height;
|
|
|
|
public Size(int width, int height)
|
|
{
|
|
this.Width = width;
|
|
this.Height = height;
|
|
}
|
|
public Size(float width, float height)
|
|
{
|
|
this.Width = (int)width;
|
|
this.Height = (int)height;
|
|
}
|
|
|
|
public int span { get { return Width * Height; } }
|
|
}
|
|
|
|
public struct KeyInput
|
|
{
|
|
public bool pressedKey, holdingKey;
|
|
public KeyCode keyCode;
|
|
|
|
public KeyInput(KeyCode keyCode)
|
|
{
|
|
this.keyCode = keyCode;
|
|
pressedKey = false;
|
|
holdingKey = false;
|
|
}
|
|
public void Update()
|
|
{
|
|
if (Input.GetKeyDown(keyCode) && !pressedKey && !holdingKey)
|
|
{
|
|
//Debug.Log("R");
|
|
pressedKey = true;
|
|
}
|
|
else if (pressedKey && !holdingKey)
|
|
{
|
|
holdingKey = true;
|
|
}
|
|
else if (Input.GetKeyUp(keyCode))
|
|
{
|
|
//Debug.Log("R - up");
|
|
holdingKey = false;
|
|
pressedKey = false;
|
|
}
|
|
}
|
|
|
|
public bool PressedKey(bool singlePress)
|
|
{
|
|
return pressedKey && (!singlePress || !holdingKey);
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class TagSlotPairing
|
|
{
|
|
public ItemTags itemTag;
|
|
public SlotUI slot;
|
|
|
|
public bool HasSlotOccupied()
|
|
{
|
|
return slot.GetItemUI() != null;
|
|
}
|
|
}
|
|
|
|
public class InventorySystem : MonoBehaviour, IPointerClickHandler
|
|
{
|
|
[SerializeField] private string[] RaritySystemUnits;
|
|
private string[] weightSystemUnitsSymbols;
|
|
[SerializeField] private string[] weightSystemUnits;
|
|
[SerializeField] private float[] currencySystemUnits;
|
|
[SerializeField] private string[] currencySystemUnitsSymbols;
|
|
public static InventorySystem instance;
|
|
public Canvas inventoryUI;
|
|
public Canvas playerUI;
|
|
private TextMeshProUGUI lootMessage;
|
|
public GameObject InventoryMenuUI;
|
|
public GameObject LootMenuUI;
|
|
public GameObject StatsMenuUI;
|
|
public KeyCode rotateKey;
|
|
public KeyCode menuKey;
|
|
public KeyCode interactKey;
|
|
public KeyCode dropItemKey;
|
|
protected KeyInput rotationKeyInput;
|
|
protected KeyInput menuKeyInput;
|
|
protected KeyInput interactKeyInput;
|
|
protected KeyInput dropItemKeyInput;
|
|
[SerializeField] private int DefaultWidthOnGrid = 100;
|
|
[SerializeField] private int DefaultHeightOnGrid = 100;
|
|
public Size DefaultSizeOnGrid;
|
|
public Camera playerCamera;
|
|
public GameObject EventsObject;
|
|
private GameObject toolbarEvents;
|
|
public StandaloneInputModule StandaloneInputModule;
|
|
public Vector2 MouseInCanvasPosition;
|
|
public ItemUI DraggedItem;
|
|
public ContextMenuManagerUI ContextMenuUI;
|
|
public static List<GameObject> hoverResults;
|
|
public Player_IS player;
|
|
public List<TagSlotPairing> TagSlotPairings;
|
|
|
|
private void Awake()
|
|
{
|
|
if (instance == null)
|
|
{
|
|
instance = this;
|
|
}
|
|
else
|
|
{
|
|
// TODO: Test this, make sure only one inventory system is active throughout the game
|
|
Destroy(gameObject);
|
|
}
|
|
DefaultSizeOnGrid = new Size(DefaultWidthOnGrid, DefaultHeightOnGrid);
|
|
|
|
rotationKeyInput = new KeyInput(rotateKey);
|
|
menuKeyInput = new KeyInput(menuKey);
|
|
interactKeyInput = new KeyInput(interactKey);
|
|
dropItemKeyInput = new KeyInput(dropItemKey);
|
|
|
|
lootMessage = playerUI.transform.Find("Loot Message").GetComponent<TextMeshProUGUI>();
|
|
if (lootMessage != null)
|
|
{
|
|
string text = lootMessage.text;
|
|
if (text.Contains("{key:interactKey}"))
|
|
lootMessage.text = lootMessage.text.Replace("{key:interactKey}", "[ " + interactKey.ToString() + " ]");
|
|
}
|
|
|
|
toolbarEvents = EventsObject.transform.Find("Toolbar").gameObject;
|
|
}
|
|
|
|
// Start is called before the first frame update
|
|
void Start()
|
|
{
|
|
InventoryMenuUI.SetActive(false);
|
|
}
|
|
|
|
// Update is called once per frame
|
|
void Update()
|
|
{
|
|
rotationKeyInput.Update();
|
|
menuKeyInput.Update();
|
|
interactKeyInput.Update();
|
|
dropItemKeyInput.Update();
|
|
|
|
//else
|
|
{
|
|
DetectObject();
|
|
}
|
|
|
|
if (menuKeyInput.PressedKey(true))
|
|
{
|
|
if(InventoryMenuUI != null)
|
|
{
|
|
ToggleInventory();
|
|
}
|
|
}
|
|
|
|
hoverResults = GetPointerOverUIObject();
|
|
}
|
|
|
|
private List<GameObject> GetPointerOverUIObject()
|
|
{
|
|
PointerEventData eventDataCurrentPosition = new PointerEventData(EventSystem.current);
|
|
eventDataCurrentPosition.position = new Vector2(Input.mousePosition.x, Input.mousePosition.y);
|
|
List<RaycastResult> results = new List<RaycastResult>();
|
|
EventSystem.current.RaycastAll(eventDataCurrentPosition, results);
|
|
List<GameObject> rGOs = new List<GameObject>();
|
|
for (int i = 0; i < results.Count; i++)
|
|
{
|
|
if (results[i].gameObject.layer == LayerMask.GetMask("Ignore Raycast"))
|
|
{
|
|
results.RemoveAt(i);
|
|
i--;
|
|
}
|
|
else// if (results[i].gameObject.layer == LayerMask.GetMask("UI"))
|
|
{
|
|
rGOs.Add(results[i].gameObject);
|
|
}
|
|
}
|
|
|
|
return rGOs;
|
|
}
|
|
|
|
public static bool IsMouseOverUI(GameObject go)
|
|
{
|
|
if(hoverResults == null || hoverResults.Count == 0)
|
|
{
|
|
return false;
|
|
}
|
|
return hoverResults.Contains(go);
|
|
}
|
|
public static bool IsMouseOverItemUITop(ItemUI item)
|
|
{
|
|
if (hoverResults == null || hoverResults.Count == 0)
|
|
{
|
|
return false;
|
|
}
|
|
foreach(GameObject go in hoverResults)
|
|
{
|
|
if(go.GetComponent<ItemUI>() != null)
|
|
{
|
|
if (go.GetComponent<ItemUI>() == item)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void FixedUpdate()
|
|
{
|
|
Vector2 movePos;
|
|
RectTransformUtility.ScreenPointToLocalPointInRectangle(inventoryUI.transform as RectTransform, Input.mousePosition, inventoryUI.worldCamera, out movePos);
|
|
|
|
MouseInCanvasPosition = InventorySystem.instance.inventoryUI.transform.TransformPoint(movePos);
|
|
}
|
|
|
|
public void ToggleInventory()
|
|
{
|
|
if (InventoryMenuUI.activeInHierarchy)
|
|
{
|
|
CloseInventory();
|
|
}
|
|
else
|
|
{
|
|
OpenInventory();
|
|
}
|
|
}
|
|
|
|
public void OpenInventory()
|
|
{
|
|
InventoryMenuUI.SetActive(true);
|
|
toolbarEvents.GetComponent<MoveChildrenUI>().MoveToTarget(false, true);
|
|
}
|
|
public void CloseInventory()
|
|
{
|
|
toolbarEvents.GetComponent<MoveChildrenUI>().MoveToSource(true, false);
|
|
InventoryMenuUI.SetActive(false);
|
|
}
|
|
|
|
|
|
public void OpenContextMenu(MonoBehaviour uiContext)
|
|
{
|
|
if (uiContext.GetType() == typeof(ItemUI))
|
|
{
|
|
ContextMenuUI.OpenContextMenu((ItemUI)uiContext);
|
|
}
|
|
}
|
|
|
|
private void DetectObject()
|
|
{
|
|
if (playerCamera == null)
|
|
{
|
|
//Debug.Log("Uh OHHH. No camera detected");
|
|
}
|
|
else
|
|
{
|
|
//Debug.Log("Detecting...");
|
|
}
|
|
Ray ray = playerCamera.ScreenPointToRay(new Vector2(Screen.width / 2, Screen.height / 2));//controls.Mouse.Position.ReadValue<Vector2>());
|
|
|
|
RaycastHit hit;
|
|
if (Physics.Raycast(ray, out hit))
|
|
{
|
|
// for single hits, i guess...
|
|
}
|
|
|
|
RaycastHit[] hits = Physics.RaycastAll(ray, 200);
|
|
for(int i = 0; i < hits.Length; i++)
|
|
{
|
|
if (hits[i].collider != null)
|
|
{
|
|
//Debug.Log("3D Hit All: " + hits[i].collider.gameObject.name);
|
|
}
|
|
|
|
|
|
if (hit.collider != null)// && hit.transform.parent.parent.parent != null)
|
|
{
|
|
PickUp response_pickUp = hit.collider.transform.GetComponent<PickUp>();
|
|
if (response_pickUp && !InventorySystem.instance.IsUsingInventoryMenuUI())
|
|
{
|
|
//Debug.Log("Detecting");
|
|
lootMessage.gameObject.SetActive(true);
|
|
|
|
if (interactKeyInput.pressedKey)
|
|
player.HandlePickup(response_pickUp);
|
|
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
lootMessage.gameObject.SetActive(false);
|
|
}
|
|
|
|
|
|
//Debug.Log("3D Hit: " + hit.collider.transform.name);
|
|
// TODO: functionality here
|
|
|
|
Inventory response_inventory = hit.collider.transform.GetComponent<Inventory>();
|
|
|
|
if(response_inventory == player.inventory)
|
|
{
|
|
continue; // ignore self
|
|
}
|
|
|
|
if (response_inventory != null && !InventorySystem.instance.IsUsingInventoryMenuUI())
|
|
{
|
|
Debug.Log("Opening Inventory");
|
|
if (interactKeyInput.PressedKey(true))
|
|
{
|
|
OpenInventory();
|
|
LootMenuUI.SetActive(true);
|
|
StatsMenuUI.SetActive(false);
|
|
lootMessage.gameObject.SetActive(false);
|
|
}
|
|
else if (!InventorySystem.instance.IsUsingInventoryMenuUI())
|
|
{
|
|
lootMessage.gameObject.SetActive(true);
|
|
}
|
|
}
|
|
else if(!InventorySystem.instance.IsUsingInventoryMenuUI())
|
|
{
|
|
lootMessage.gameObject.SetActive(false);
|
|
LootMenuUI.SetActive(false);
|
|
StatsMenuUI.SetActive(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*RaycastHit[] hitsNonAlloc = new RaycastHit[1];
|
|
int numberOfHits = Physics.RaycastNonAlloc(ray, hitsNonAlloc);
|
|
for (int i = 0; i < numberOfHits; i++)
|
|
{
|
|
if (hitsNonAlloc[i].collider != null)
|
|
{
|
|
Debug.Log("3D Hit Non Alloc All: " + hitsNonAlloc[i].collider.tag);
|
|
}
|
|
}*/
|
|
}
|
|
|
|
/// <summary>
|
|
/// This can be called to check if player is interacting with the Inventory System's UI
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool IsUsingInventoryMenuUI()
|
|
{
|
|
return InventoryMenuUI.activeInHierarchy;
|
|
}
|
|
|
|
public bool PressedKeyRotation(bool singlePress)
|
|
{
|
|
return rotationKeyInput.PressedKey(singlePress);
|
|
}
|
|
public bool PressedDropItemKey(bool singlePress)
|
|
{
|
|
return dropItemKeyInput.PressedKey(singlePress);
|
|
}
|
|
|
|
public void OnPointerClick(PointerEventData eventData)
|
|
{
|
|
}
|
|
}
|
|
} |