scove/BABA_YAGA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update

Browse Source
This commit is contained in:
Scove
2026-06-09 09:18:17 +07:00
parent 3578a2750c
commit 71a096556a
5777 changed files with 6675 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

341
Assets/Opsive/UltimateCharacterController/Scripts/Items/Actions/UsableItem.cs
View File

@@ -1,341 +0,0 @@
/// ---------------------------------------------
/// Ultimate Character Controller
/// Copyright (c) Opsive. All Rights Reserved.
/// https://www.opsive.com
/// ---------------------------------------------
namespace Opsive.UltimateCharacterController.Items.Actions
{
using Opsive.Shared.Events;
using Opsive.Shared.Game;
using Opsive.Shared.Inventory;
using Opsive.UltimateCharacterController.Character;
using Opsive.UltimateCharacterController.Character.Abilities;
using Opsive.UltimateCharacterController.Character.Abilities.Items;
using Opsive.UltimateCharacterController.Items.AnimatorAudioStates;
using Opsive.UltimateCharacterController.Traits;
using Opsive.UltimateCharacterController.Utility;
using UnityEngine;
/// <summary>
/// Base class for any item that can be used.
/// </summary>
public abstract class UsableItem : ItemAction, IUsableItem
{
/// <summary>
/// Defines the statue of the Use Ability when calling CanUseItem.
/// </summary>
public enum UseAbilityState
{
Start, // The Use ability is starting.
Update, // The Use ability is updating.
None // The ability is not used.
}
[Tooltip("The amount of time that must elapse before the item can be used again.")]
[SerializeField] protected float m_UseRate = 0.1f;
[Tooltip("Specifies if the inventory can equip an item that doesn't have any consumable items left.")]
[SerializeField] protected bool m_CanEquipEmptyItem = true;
[Tooltip("Should the character rotate to face the target during use?")]
[SerializeField] protected bool m_FaceTarget = true;
[Tooltip("The amount of extra time it takes for the ability to stop after use.")]
[SerializeField] protected float m_StopUseAbilityDelay = 1f;
[Tooltip("Specifies if the item should wait for the OnAnimatorItemUse animation event or wait for the specified duration before being used.")]
[SerializeField] protected AnimationEventTrigger m_UseEvent = new AnimationEventTrigger(true, 0.2f);
[Tooltip("Specifies if the item should wait for the OnAnimatorItemUseComplete animation event or wait for the specified duration before completing the use.")]
[SerializeField] protected AnimationEventTrigger m_UseCompleteEvent = new AnimationEventTrigger(false, 0.05f);
[Tooltip("Does the item require root motion position during use?")]
[SerializeField] protected bool m_ForceRootMotionPosition;
[Tooltip("Does the item require root motion rotation during use?")]
[SerializeField] protected bool m_ForceRootMotionRotation;
[Tooltip("The name of the attribute that should be adjusted when the item is used.")]
[SerializeField] protected string m_UseAttributeName;
[Tooltip("The amount to adjust the Use Attribute by when the item is used.")]
[SerializeField] protected float m_UseAttributeAmount;
[Tooltip("Should the item be dropped when the use attribute is depleted?")]
[SerializeField] protected bool m_DropWhenUseDepleted;
[Tooltip("The name of the character attribute that should be adjusted when the item is used.")]
[SerializeField] protected string m_CharacterUseAttributeName;
[Tooltip("The amount to adjust the Character Use Attribute by when the item is used.")]
[SerializeField] protected float m_CharacterUseAttributeAmount;
[Tooltip("Should the audio play when the item starts to be used? If false it will be played when the item is used.")]
[SerializeField] protected bool m_PlayAudioOnStartUse = false;
[Tooltip("Specifies the animator and audio state that should be triggered when the item is used.")]
[SerializeField] protected AnimatorAudioStateSet m_UseAnimatorAudioStateSet = new AnimatorAudioStateSet(2);
public float UseRate { get { return m_UseRate; } set { m_UseRate = value; } }
public bool CanEquipEmptyItem { get { return m_CanEquipEmptyItem; } set { m_CanEquipEmptyItem = value; } }
public bool FaceTarget { get { return m_FaceTarget; } set { m_FaceTarget = value; } }
public float StopUseAbilityDelay { get { return m_StopUseAbilityDelay; } set { m_StopUseAbilityDelay = value; } }
public AnimationEventTrigger UseEvent { get { return m_UseEvent; } set { m_UseEvent = value; } }
public AnimationEventTrigger UseCompleteEvent { get { return m_UseCompleteEvent; } set { m_UseCompleteEvent = value; } }
public bool ForceRootMotionPosition { get { return m_ForceRootMotionPosition; } set { m_ForceRootMotionPosition = value; } }
public bool ForceRootMotionRotation { get { return m_ForceRootMotionRotation; } set { m_ForceRootMotionRotation = value; } }
public string UseAttributeName
{
get { return m_UseAttributeName; }
set
{
m_UseAttributeName = value;
if (Application.isPlaying) {
if (!string.IsNullOrEmpty(m_UseAttributeName) && m_AttributeManager != null) {
m_UseAttribute = m_AttributeManager.GetAttribute(m_UseAttributeName);
} else {
m_UseAttribute = null;
}
}
}
}
public float UseAttributeAmount { get { return m_UseAttributeAmount; } set { m_UseAttributeAmount = value; } }
public bool DropWhenUseDepleted { get { return m_DropWhenUseDepleted; } set { m_DropWhenUseDepleted = value; } }
public string CharacterUseAttributeName
{
get { return m_CharacterUseAttributeName; }
set
{
m_CharacterUseAttributeName = value;
if (Application.isPlaying) {
if (!string.IsNullOrEmpty(m_CharacterUseAttributeName) && m_CharacterUseAttributeManager != null) {
m_CharacterUseAttribute = m_CharacterUseAttributeManager.GetAttribute(m_CharacterUseAttributeName);
} else {
m_CharacterUseAttribute = null;
}
}
}
}
public float CharacterUseAttributeAmount { get { return m_CharacterUseAttributeAmount; } set { m_CharacterUseAttributeAmount = value; } }
public bool PlayAudioOnStartUse { get { return m_PlayAudioOnStartUse; } set { m_PlayAudioOnStartUse = value; } }
public AnimatorAudioStateSet UseAnimatorAudioStateSet { get { return m_UseAnimatorAudioStateSet; } set { m_UseAnimatorAudioStateSet = value; } }
protected ILookSource m_LookSource;
private AttributeManager m_AttributeManager;
private AttributeManager m_CharacterUseAttributeManager;
protected Attribute m_UseAttribute;
protected Attribute m_CharacterUseAttribute;
protected float m_NextAllowedUseTime;
private bool m_InUse;
/// <summary>
/// Initialize the default values.
/// </summary>
protected override void Awake()
{
base.Awake();
// The item may have been added at runtime in which case the look source has already been populated.
var characterLocomotion = m_Character.GetCachedComponent<UltimateCharacterLocomotion>();
m_LookSource = characterLocomotion.LookSource;
m_UseAnimatorAudioStateSet.DeserializeAnimatorAudioStateSelector(m_Item, characterLocomotion);
m_UseAnimatorAudioStateSet.Awake(m_Item.gameObject);
m_AttributeManager = GetComponent<AttributeManager>();
if (m_AttributeManager != null) {
m_UseAttribute = m_AttributeManager.GetAttribute(m_UseAttributeName);
if (m_UseAttribute != null) {
EventHandler.RegisterEvent(m_UseAttribute, "OnAttributeReachedDestinationValue", UseDepleted);
}
}
m_CharacterUseAttributeManager = m_Character.GetCachedComponent<AttributeManager>();
if (m_CharacterUseAttributeManager != null) {
m_CharacterUseAttribute = m_CharacterUseAttributeManager.GetAttribute(m_CharacterUseAttributeName);
}
m_NextAllowedUseTime = Time.time;
EventHandler.RegisterEvent<ILookSource>(m_Character, "OnCharacterAttachLookSource", OnAttachLookSource);
}
/// <summary>
/// A new ILookSource object has been attached to the character.
/// </summary>
/// <param name="lookSource">The ILookSource object attached to the character.</param>
private void OnAttachLookSource(ILookSource lookSource)
{
m_LookSource = lookSource;
}
/// <summary>
/// Returns the ItemIdentifier which can be used by the item.
/// </summary>
/// <returns>The ItemIdentifier which can be used by the item.</returns>
public virtual IItemIdentifier GetConsumableItemIdentifier() { return null; }
/// <summary>
/// Returns the amount of UsableItemIdentifier which has been consumed by the UsableItem.
/// </summary>
/// <returns>The amount consumed of the UsableItemIdentifier.</returns>
public virtual int GetConsumableItemIdentifierAmount() { return 0; }
/// <summary>
/// Sets the UsableItemIdentifier amount on the UsableItem.
/// </summary>
/// <param name="amount">The amount to set the UsableItemIdentifier to.</param>
public virtual void SetConsumableItemIdentifierAmount(int amount) { }
/// <summary>
/// Removes the amount of UsableItemIdentifier which has been consumed by the UsableItem.
/// </summary>
public virtual void RemoveConsumableItemIdentifierAmount() { }
/// <summary>
/// Can the item be used?
/// </summary>
/// <param name="itemAbility">The itemAbility that is trying to use the item.</param>
/// <param name="abilityState">The state of the Use ability when calling CanUseItem.</param>
/// <returns>True if the item can be used.</returns>
public virtual bool CanUseItem(ItemAbility itemAbility, UseAbilityState abilityState)
{
// Prevent the item from being used too soon.
if (Time.time < m_NextAllowedUseTime) {
return false;
}
// The attribute may prevent the item from being used (such as if the character doesn't have enough stamina to use the item).
if ((m_UseAttribute != null && !m_UseAttribute.IsValid(abilityState == UseAbilityState.Start ? 0 : -m_UseAttributeAmount)) ||
(m_CharacterUseAttribute != null && !m_CharacterUseAttribute.IsValid(abilityState == UseAbilityState.Start ? 0 : -m_CharacterUseAttributeAmount))) {
// The item can no longer be used. Stop the ability.
if (abilityState != UseAbilityState.Start) {
itemAbility.StopAbility();
}
return false;
}
return true;
}
/// <summary>
/// Can the ability be started?
/// </summary>
/// <param name="ability">The ability that is trying to start.</param>
/// <returns>True if the ability can be started.</returns>
public virtual bool CanStartAbility(Ability ability) { return true; }
/// <summary>
/// Starts the item use.
/// </summary>
/// <param name="itemAbility">The item ability that is using the item.</param>
public virtual void StartItemUse(ItemAbility useAbility)
{
// The use AnimatorAudioState is starting.
m_UseAnimatorAudioStateSet.StartStopStateSelection(true);
m_InUse = m_UseAnimatorAudioStateSet.NextState();
if (m_InUse && m_PlayAudioOnStartUse) {
var visibleObject = m_Item.GetVisibleObject() != null ? m_Item.GetVisibleObject() : m_Character;
m_UseAnimatorAudioStateSet.PlayAudioClip(visibleObject);
}
}
/// <summary>
/// Uses the item.
/// </summary>
public virtual void UseItem()
{
#if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER
if (m_NetworkInfo == null || m_NetworkInfo.IsLocalPlayer()) {
#endif
m_NextAllowedUseTime = Time.time + m_UseRate;
if (m_UseAttribute != null) {
m_UseAttribute.Value -= m_UseAttributeAmount;
}
if (m_CharacterUseAttribute != null) {
m_CharacterUseAttribute.Value -= m_CharacterUseAttributeAmount;
}
#if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER
}
#endif
// Optionally play a use sound based upon the use animation.
if (!m_PlayAudioOnStartUse) {
var visibleObject = m_Item.GetVisibleObject() != null ? m_Item.GetVisibleObject() : m_Character;
m_UseAnimatorAudioStateSet.PlayAudioClip(visibleObject);
}
}
/// <summary>
/// Is the item in use?
/// </summary>
/// <returns>True if the item is in use.</returns>
public virtual bool IsItemInUse()
{
return m_InUse;
}
/// <summary>
/// Is the item waiting to be used? This will return true if the item is waiting to be charged or pulled back.
/// </summary>
/// <returns>Returns true if the item is waiting to be used.</returns>
public virtual bool IsItemUsePending() { return false; }
/// <summary>
/// Returns the substate index that the item should be in.
/// </summary>
/// <returns>the substate index that the item should be in.</returns>
public virtual int GetItemSubstateIndex()
{
return m_UseAnimatorAudioStateSet.GetItemSubstateIndex();
}
/// <summary>
/// Allows the item to update while it is being used.
/// </summary>
public virtual void UseItemUpdate() { }
/// <summary>
/// The item has been used.
/// </summary>
public virtual void ItemUseComplete() { }
/// <summary>
/// Tries to stop the item use.
/// </summary>
public virtual void TryStopItemUse() { }
/// <summary>
/// Can the item use be stopped?
/// </summary>
/// <returns>True if the item use can be stopped.</returns>
public virtual bool CanStopItemUse()
{
return true;
}
/// <summary>
/// Stops the item use.
/// </summary>
public virtual void StopItemUse()
{
m_InUse = false;
// The item has been used- inform the state set.
m_UseAnimatorAudioStateSet.StartStopStateSelection(false);
}
/// <summary>
/// The item has depleted its use attribute.
/// </summary>
private void UseDepleted()
{
if (!m_DropWhenUseDepleted) {
return;
}
// Remove the item from the inventory before dropping it. This will ensure the dropped prefab does not contain any ItemIdentifier amount so the
// item can't be picked up again.
m_Inventory.RemoveItem(m_Item.ItemIdentifier, m_Item.SlotID, int.MaxValue, false);
m_Item.Drop(int.MaxValue, true);
}
/// <summary>
/// The GameObject has been destroyed.
/// </summary>
protected override void OnDestroy()
{
base.OnDestroy();
m_UseAnimatorAudioStateSet.OnDestroy();
EventHandler.UnregisterEvent<ILookSource>(m_Character, "OnCharacterAttachLookSource", OnAttachLookSource);
if (m_UseAttribute != null) {
EventHandler.UnregisterEvent(m_UseAttribute, "OnAttributeReachedDestinationValue", UseDepleted);
}
}
}
}