336 lines
11 KiB
C#
336 lines
11 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using InfallibleCode;
|
|
using System.Reflection;
|
|
using System;
|
|
using TRInventoryUpdatable;
|
|
|
|
public class KeyPickup : MonoBehaviour
|
|
{
|
|
public ExaminableItem examinableItem;
|
|
|
|
[SerializeField] private string KeyNameID;
|
|
//public int KeyID;
|
|
private bool _canPickupKeyItem;
|
|
//public bool _canPressButtonDown = true;
|
|
public bool hasKey;
|
|
[HideInInspector] public bool ItemCollected;
|
|
public MeshRenderer _KeyGameObject;
|
|
public GameObject keyModelForKeyHole;
|
|
|
|
public string keyModelName;
|
|
public string keyNameInInventory;
|
|
|
|
public bool IsReusable;
|
|
public bool shouldDestroyKey = true;
|
|
|
|
private BodyPartJointHole bodyPartJointHole;
|
|
Transform bodyPartPivotPosition;
|
|
|
|
PickupEvent pickupEvent;
|
|
|
|
public enum KeyType
|
|
{
|
|
DoorKeyType,
|
|
BodyPartKeyType
|
|
}
|
|
|
|
public KeyType keyType = KeyType.DoorKeyType;
|
|
|
|
public EventDelegateTrigger eventDelegateTriggerOnKeyObtained;
|
|
|
|
//private void OnEnable()
|
|
//{
|
|
// if (hasKey)
|
|
// {
|
|
// gameObject.SetActive(false);
|
|
// }
|
|
//}
|
|
|
|
void Start()
|
|
{
|
|
//foreach (MeshRenderer keyGameObject in _KeyGameObject)
|
|
//{
|
|
// keyGameObject = GetComponentsInChildren<MeshRenderer>();
|
|
//}
|
|
if (_KeyGameObject == null)
|
|
{
|
|
_KeyGameObject = GetComponentInChildren<MeshRenderer>();
|
|
}
|
|
|
|
if (TryGetComponent<ExaminableItem>(out ExaminableItem _examinableItem))
|
|
{
|
|
examinableItem = _examinableItem;
|
|
}
|
|
|
|
if (TryGetComponent(out PickupEvent _pickupEvent))
|
|
{
|
|
pickupEvent = _pickupEvent;
|
|
}
|
|
}
|
|
|
|
// Update is called once per frame
|
|
void Update()
|
|
{
|
|
#region Old Implementation
|
|
//if (_canPickupKeyItem && _canPressButtonDown)
|
|
//{
|
|
// if (Input.GetKeyDown(KeyCode.E))
|
|
// {
|
|
// hasKey = true;
|
|
// _canPickupKeyItem = false;
|
|
// _canPressButtonDown = false;
|
|
// Destroy(gameObject);
|
|
|
|
// #region Debugging
|
|
// print("You picked up the key!");
|
|
// #endregion
|
|
// }
|
|
//}
|
|
#endregion
|
|
|
|
PickUpKey();
|
|
}
|
|
|
|
void PickUpKey()
|
|
{
|
|
//Change later to update from a coroutine
|
|
if (examinableItem != null)
|
|
{
|
|
if (/*_canPickupKeyItem && *//*_canPressButtonDown*/examinableItem.examineItem.CanPressButtonToGetItem && examinableItem.examineItem.CurrenltyExaminingObj)
|
|
{
|
|
if (Input.GetKeyDown(KeyCode.E) || Input.GetKeyDown(KeyCode.JoystickButton0))
|
|
{
|
|
hasKey = true;
|
|
ItemCollected = true;
|
|
_canPickupKeyItem = false;
|
|
examinableItem.examineItem.CanPressButtonToGetItem = false;
|
|
UIManager.GetInstance().userInterfaceIsOnScreen = false;
|
|
//_canPressButtonDown = false;
|
|
|
|
if (pickupEvent != null)
|
|
{
|
|
pickupEvent.eventAfterPickup.Invoke();
|
|
}
|
|
|
|
#region Body part keypickup related
|
|
//TryGetBodyPartJointHoleComponentInParent<BodyPartJointHole>();
|
|
|
|
if (TryGetComponent(out BodyPartKeyAdditional bodyPartKeyAdditional))
|
|
{
|
|
if (bodyPartKeyAdditional.bodyPartJointHoleOfThisBodyPart != null)
|
|
{
|
|
bodyPartKeyAdditional.bodyPartJointHoleOfThisBodyPart.hasBodyPartInserted = false;
|
|
bodyPartKeyAdditional.bodyPartJointHoleOfThisBodyPart.hasCorrectBodyPartInserted = false;
|
|
bodyPartKeyAdditional.bodyPartJointHoleOfThisBodyPart.afterAttachOrDetachEvent.Invoke();
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("bodyPartJointHoleOfThisBodyPart in BodyPartKeyAdditional Component is NULL.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("BodyPartKeyAdditional Component not found.");
|
|
}
|
|
|
|
//if (TryGetComponent(out BodyPartJointHole _bodyPartJointHole))
|
|
//{
|
|
// bodyPartJointHole = _bodyPartJointHole;
|
|
// bodyPartJointHole.hasBodyPartInserted = false;
|
|
// bodyPartJointHole.hasCorrectBodyPartInserted = false;
|
|
//}
|
|
|
|
#endregion
|
|
|
|
StartCoroutine(PickingUpObject());
|
|
|
|
#region Debugging
|
|
print("You picked up the key!");
|
|
#endregion
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TryGetBodyPartJointHoleComponentInParent<T>() where T : MonoBehaviour, IInteractable
|
|
{
|
|
if (examinableItem.examineItem._item3DParent != null)
|
|
{
|
|
// Try to get the component in the parent GameObject
|
|
T component = GetComponentInParent<T>();
|
|
|
|
// If the component is found, store it
|
|
if (component != null)
|
|
{
|
|
bodyPartJointHole = component as BodyPartJointHole;
|
|
bodyPartJointHole.hasBodyPartInserted = false;
|
|
bodyPartJointHole.hasCorrectBodyPartInserted = false;
|
|
bodyPartJointHole.afterAttachOrDetachEvent.Invoke();
|
|
Debug.Log("Found " + typeof(T).ToString() + " in parent");
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("No " + typeof(T).ToString() + " found");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
print("No parent found");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maybe you can call this from a unity event in the scene.
|
|
/// </summary>
|
|
public void AddKeyToInventory()
|
|
{
|
|
hasKey = true;
|
|
ItemCollected = true;
|
|
_canPickupKeyItem = false;
|
|
StartCoroutine(PickingUpObject());
|
|
print("Is Adding key to Inventory");
|
|
}
|
|
|
|
IEnumerator PickingUpObject()
|
|
{
|
|
KeysManager.GetInstance().AddKeyNameID(KeyNameID);
|
|
//First instantiate the key model you want:
|
|
GameObject key = Instantiate(AccessFieldInInventoryManager(keyModelName).gameObject,
|
|
InventoryManager.GetInstance().TransformWithPosRotForItemsToAdd.position,
|
|
InventoryManager.GetInstance().TransformWithPosRotForItemsToAdd.rotation,
|
|
InventoryManager.GetInstance().itemsToAddTransform);
|
|
|
|
//Set the key name that's going to show up when the player is in the selection of the key's slot.
|
|
KeyInventoryItem keyInventoryItem = key.GetComponent<KeyInventoryItem>();
|
|
keyInventoryItem.keyNameInInventory = keyNameInInventory;
|
|
keyInventoryItem.keyNameID = KeyNameID;
|
|
keyInventoryItem.IsReusable = IsReusable;
|
|
if (keyModelForKeyHole != null)
|
|
{
|
|
keyInventoryItem.keyModelForKeyHole = keyModelForKeyHole;
|
|
}
|
|
//keyInventoryItem.keyTypeString = keyType.ToString();
|
|
//Add the new instantiated item into the keysAndItemsInventory
|
|
RingInventory.GetInstance().AddItemToKeysAndItemsInventory(key.transform);
|
|
//key.GetComponentInChildren<GameObject>().gameObject.layer = 5; //Added today 11/08/24 Yiannis
|
|
ChangeLayerRecursively(key.transform, 5);
|
|
|
|
#region SAVE TEMPORARILY THE KEY ITEM
|
|
InventoryManager.GetInstance().SaveTemporarilyKeyInventoryItemData(KeyNameID/*, keyModelForKeyHole.name*/, keyModelName, keyNameInInventory, gameObject.name, IsReusable);
|
|
#endregion
|
|
#region SAVE TEMPORARILY THE PICKUP
|
|
//InventoryManager.GetInstance().SaveTemporarilyObtainedItemsData(gameObject.name);
|
|
#endregion
|
|
|
|
if (shouldDestroyKey)
|
|
{
|
|
Destroy(_KeyGameObject.gameObject);
|
|
}
|
|
yield return new WaitForSecondsRealtime(0.1f);
|
|
if (examinableItem != null)
|
|
{
|
|
examinableItem.examineItem.GotItemExitDisplayingItem3d();
|
|
}
|
|
if (eventDelegateTriggerOnKeyObtained != null)
|
|
{
|
|
eventDelegateTriggerOnKeyObtained?.OnEventInvoke();
|
|
}
|
|
yield return new WaitForSecondsRealtime(0.1f);
|
|
if (shouldDestroyKey)
|
|
{
|
|
Destroy(gameObject);
|
|
}
|
|
}
|
|
|
|
void ChangeLayerRecursively(Transform obj, int newLayer)
|
|
{
|
|
// Skip changing the layer if the object has the VisibilityIcon script
|
|
if (obj.GetComponent<VisibilityIcon>() != null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Change the layer of the current child object
|
|
obj.gameObject.layer = newLayer;
|
|
|
|
// Recursively change the layer of all children
|
|
foreach (Transform child in obj)
|
|
{
|
|
ChangeLayerRecursively(child, newLayer);
|
|
}
|
|
}
|
|
|
|
public GameObject AccessFieldInInventoryManager(string fieldName)
|
|
{
|
|
if (InventoryManager.GetInstance() == null)
|
|
{
|
|
Debug.LogWarning("InventoryManager instance not found.");
|
|
return null;
|
|
}
|
|
|
|
// Get the InventoryManager instance
|
|
InventoryManager inventoryManager = InventoryManager.GetInstance();
|
|
|
|
// Start a recursive search for the field in InventoryManager
|
|
return FindFieldRecursively(inventoryManager, fieldName);
|
|
}
|
|
|
|
private GameObject FindFieldRecursively(object currentObject, string fieldName)
|
|
{
|
|
if (currentObject == null)
|
|
return null;
|
|
|
|
// Get the type of the current object
|
|
Type type = currentObject.GetType();
|
|
|
|
// First, check if the field exists at the current level
|
|
FieldInfo field = type.GetField(fieldName, BindingFlags.Public | BindingFlags.Instance);
|
|
if (field != null)
|
|
{
|
|
// If the field exists and is a GameObject, return it
|
|
return field.GetValue(currentObject) as GameObject;
|
|
}
|
|
|
|
// If the field is not found, search all public instance fields of the current object
|
|
FieldInfo[] allFields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
|
|
foreach (FieldInfo subField in allFields)
|
|
{
|
|
// Get the value of the subfield (e.g., a nested class or struct)
|
|
object subFieldValue = subField.GetValue(currentObject);
|
|
|
|
if (subFieldValue == null)
|
|
continue;
|
|
|
|
// Recursively search within this subfield
|
|
GameObject result = FindFieldRecursively(subFieldValue, fieldName);
|
|
if (result != null)
|
|
{
|
|
return result; // If found in the nested field, return it
|
|
}
|
|
}
|
|
|
|
// If the field is not found in this object or its nested fields, return null
|
|
return null;
|
|
}
|
|
|
|
#region Old Implementation
|
|
//private void OnTriggerStay(Collider col)
|
|
//{
|
|
// if (col.gameObject.tag == "Player")
|
|
// {
|
|
// _canPickupKeyItem = true;
|
|
// }
|
|
//}
|
|
|
|
//private void OnTriggerExit(Collider col)
|
|
//{
|
|
// if (col.gameObject.tag == "Player")
|
|
// {
|
|
// _canPickupKeyItem = false;
|
|
// }
|
|
//}
|
|
#endregion
|
|
}
|