tomh104/Virtual-Tutor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

restructure

Browse Source
This commit is contained in:
tom.hempel
2025-09-30 18:03:19 +02:00
parent 69b0c79692
commit 78e5dcd53e
4821 changed files with 762 additions and 417 deletions
Download Patch File Download Diff File Expand all files Collapse all files

787
Unity/Assets/Convai/Scripts/Runtime/Features/Actions/ConvaiActionsHandler.cs Normal file
View File

@ -0,0 +1,787 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Convai.Scripts.Runtime.Core;
using Convai.Scripts.Runtime.LoggerSystem;
using Service;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Serialization;
namespace Convai.Scripts.Runtime.Features
{
// STEP 1: Add the enum for your custom action here.
public enum ActionChoice
{
None,
Jump,
Crouch,
MoveTo,
PickUp,
Drop
}
/// <summary>
/// DISCLAIMER: The action API is in experimental stages and can misbehave. Meanwhile, feel free to try it out and play
/// around with it.
/// </summary>
[DisallowMultipleComponent]
[AddComponentMenu("Convai/Convai Actions Handler")]
public class ConvaiActionsHandler : MonoBehaviour
{
[SerializeField] public ActionMethod[] actionMethods;
public List<string> actionResponseList = new();
private readonly List<ConvaiAction> _actionList = new();
public readonly ActionConfig ActionConfig = new();
private List<string> _actions = new();
private ConvaiNPC _currentNPC;
private ConvaiInteractablesData _interactablesData;
private Coroutine _playActionListCoroutine;
// Awake is called when the script instance is being loaded
private void Awake()
{
// Find the global action settings object in the scene
_interactablesData = FindObjectOfType<ConvaiInteractablesData>();
// Check if the global action settings object is missing
if (_interactablesData == null)
// Log an error message to indicate missing Convai Action Settings
ConvaiLogger.Error("Convai Action Settings missing. Please create a game object that handles actions.",
ConvaiLogger.LogCategory.Character);
// Check if this GameObject has a ConvaiNPC component attached
if (TryGetComponent(out ConvaiNPC npc))
// If it does, set the current NPC to this GameObject
_currentNPC = npc;
// Iterate through each action method and add its name to the action configuration
foreach (ActionMethod actionMethod in actionMethods) ActionConfig.Actions.Add(actionMethod.action);
if (_interactablesData != null)
{
// Iterate through each character in global action settings and add them to the action configuration
foreach (ConvaiInteractablesData.Character character in _interactablesData.Characters)
{
ActionConfig.Types.Character rpcCharacter = new()
{
Name = character.Name,
Bio = character.Bio
};
ActionConfig.Characters.Add(rpcCharacter);
}
// Iterate through each object in global action settings and add them to the action configuration
foreach (ConvaiInteractablesData.Object eachObject in _interactablesData.Objects)
{
ActionConfig.Types.Object rpcObject = new()
{
Name = eachObject.Name,
Description = eachObject.Description
};
ActionConfig.Objects.Add(rpcObject);
}
}
}
private void Reset()
{
actionMethods = new ActionMethod[]
{
new() { action = "Move To", actionChoice = ActionChoice.MoveTo },
new() { action = "Pick Up", actionChoice = ActionChoice.PickUp },
new() { action = "Dance", animationName = "Dance", actionChoice = ActionChoice.None },
new() { action = "Drop", actionChoice = ActionChoice.Drop },
new() { action = "Jump", actionChoice = ActionChoice.Jump }
};
}
// Start is called before the first frame update
private void Start()
{
// Set up the action configuration
#region Actions Setup
// Set the classification of the action configuration to "multistep"
ActionConfig.Classification = "multistep";
// Log the configured action information
ConvaiLogger.DebugLog(ActionConfig, ConvaiLogger.LogCategory.Actions);
#endregion
// Start playing the action list using a coroutine
_playActionListCoroutine = StartCoroutine(PlayActionList());
}
private void OnEnable() {
if ( _playActionListCoroutine != null ) {
_playActionListCoroutine = StartCoroutine(PlayActionList());
}
}
private void OnDisable() {
if ( _playActionListCoroutine != null ) {
StopCoroutine(_playActionListCoroutine);
}
}
private void Update()
{
if (actionResponseList.Count > 0)
{
ParseActions(actionResponseList[0]);
actionResponseList.RemoveAt(0);
}
}
private void ParseActions(string actionsString)
{
actionsString = actionsString.Trim();
ConvaiLogger.DebugLog($"Parsing actions from: {actionsString}", ConvaiLogger.LogCategory.Actions);
_actions = actionsString.Split(", ").ToList();
_actionList.Clear();
foreach (string action in _actions)
{
List<string> actionWords = action.Split(' ').ToList();
ConvaiLogger.Info($"Processing action: {action}", ConvaiLogger.LogCategory.Actions);
ParseSingleAction(actionWords);
}
}
/// <summary>
/// Parses a single action from a list of action words.
/// </summary>
/// <param name="actionWords">The list of words representing the action.</param>
private void ParseSingleAction(List<string> actionWords)
{
for (int j = 0; j < actionWords.Count; j++)
{
// Split the action into verb and object parts
string[] verbPart = actionWords.Take(j + 1).ToArray();
string[] objectPart = actionWords.Skip(j + 1).ToArray();
// Remove trailing 's' from verb words
verbPart = verbPart.Select(word => word.TrimEnd('s')).ToArray();
string actionString = string.Join(" ", verbPart);
// Find the best matching action using Levenshtein distance
ActionMethod matchingAction = actionMethods
.OrderBy(a => LevenshteinDistance(a.action.ToLower(), actionString.ToLower()))
.FirstOrDefault();
// If no close match is found, continue to the next iteration
if (matchingAction == null || LevenshteinDistance(matchingAction.action.ToLower(), actionString.ToLower()) > 2) continue;
// Find the target object for the action
GameObject targetObject = FindTargetObject(objectPart);
LogActionResult(verbPart, objectPart, targetObject);
// Add the parsed action to the action list
_actionList.Add(new ConvaiAction(matchingAction.actionChoice, targetObject, matchingAction.animationName));
break;
}
}
/// <summary>
/// Finds the target object based on the object part of the action.
/// </summary>
/// <param name="objectPart">The array of words representing the object.</param>
/// <returns>The GameObject that best matches the object description, or null if no match is found.</returns>
private GameObject FindTargetObject(string[] objectPart)
{
string targetName = string.Join(" ", objectPart);
// Try to find a matching object
ConvaiInteractablesData.Object obj = _interactablesData.Objects
.OrderBy(o => LevenshteinDistance(o.Name.ToLower(), targetName.ToLower()))
.FirstOrDefault();
if (obj != null && LevenshteinDistance(obj.Name.ToLower(), targetName.ToLower()) <= 2)
return obj.gameObject;
// If no object is found, try to find a matching character
ConvaiInteractablesData.Character character = _interactablesData.Characters
.OrderBy(c => LevenshteinDistance(c.Name.ToLower(), targetName.ToLower()))
.FirstOrDefault();
if (character != null && LevenshteinDistance(character.Name.ToLower(), targetName.ToLower()) <= 2)
return character.gameObject;
return null;
}
/// <summary>
/// Calculates the Levenshtein distance between two strings.
/// </summary>
/// <param name="s">The first string.</param>
/// <param name="t">The second string.</param>
/// <returns>The Levenshtein distance between the two strings.</returns>
private int LevenshteinDistance(string s, string t)
{
int[][] d = new int[s.Length + 1][];
for (int index = 0; index < s.Length + 1; index++) d[index] = new int[t.Length + 1];
// Initialize the first row and column
for (int i = 0; i <= s.Length; i++)
d[i][0] = i;
for (int j = 0; j <= t.Length; j++)
d[0][j] = j;
// Calculate the distance
for (int j = 1; j <= t.Length; j++)
for (int i = 1; i <= s.Length; i++)
{
int cost = s[i - 1] == t[j - 1] ? 0 : 1;
d[i][j] = Math.Min(Math.Min(d[i - 1][j] + 1, d[i][j - 1] + 1), d[i - 1][j - 1] + cost);
}
return d[s.Length][t.Length];
}
private void LogActionResult(string[] verbPart, string[] objectPart, GameObject targetObject)
{
string verb = string.Join(" ", verbPart).ToLower();
string obj = string.Join(" ", objectPart).ToLower();
if (targetObject != null)
{
ConvaiLogger.DebugLog($"Active Target: {obj}", ConvaiLogger.LogCategory.Actions);
ConvaiLogger.DebugLog($"Found matching target: {targetObject.name} for action: {verb}", ConvaiLogger.LogCategory.Actions);
}
else
{
ConvaiLogger.Warn($"No matching target found for action: {verb}", ConvaiLogger.LogCategory.Actions);
}
}
/// <summary>
/// Event that is triggered when an action starts.
/// </summary>
/// <remarks>
/// This event can be subscribed to in order to perform custom logic when an action starts.
/// The event provides the name of the action and the GameObject that the action is targeting.
/// </remarks>
public event Action<string, GameObject> ActionStarted;
/// <summary>
/// Event that is triggered when an action ends.
/// </summary>
/// <remarks>
/// This event can be subscribed to in order to perform custom logic when an action ends.
/// The event provides the name of the action and the GameObject that the action was targeting.
/// </remarks>
public event Action<string, GameObject> ActionEnded;
/// <summary>
/// This coroutine handles playing the actions in the action list.
/// </summary>
/// <returns></returns>
private IEnumerator PlayActionList()
{
while (true)
// Check if there are actions in the action list
if (_actionList.Count > 0)
{
// Call the DoAction function for the first action in the list and wait until it's done
yield return DoAction(_actionList[0]);
// Remove the completed action from the list
_actionList.RemoveAt(0);
}
else
{
// If there are no actions in the list, yield to wait for the next frame
yield return null;
}
}
private IEnumerator DoAction(ConvaiAction action)
{
// STEP 2: Add the function call for your action here corresponding to your enum.
// Remember to yield until its return if it is an Enumerator function.
// Use a switch statement to handle different action choices based on the ActionChoice enum
switch (action.Verb)
{
case ActionChoice.MoveTo:
// Call the MoveTo function and yield until it's completed
yield return MoveTo(action.Target);
break;
case ActionChoice.PickUp:
// Call the PickUp function and yield until it's completed
yield return PickUp(action.Target);
break;
case ActionChoice.Drop:
// Call the Drop function
Drop(action.Target);
break;
case ActionChoice.Jump:
// Call the Jump function
Jump();
break;
case ActionChoice.Crouch:
// Call the Crouch function and yield until it's completed
yield return Crouch();
break;
case ActionChoice.None:
// Call the AnimationActions function and yield until it's completed
yield return AnimationActions(action.Animation);
break;
default:
throw new ArgumentOutOfRangeException();
}
// Yield once to ensure the coroutine advances to the next frame
yield return null;
}
/// <summary>
/// This method is a coroutine that handles playing an animation for Convai NPC.
/// The method takes in the name of the animation to be played as a string parameter.
/// </summary>
/// <param name="animationName"> The name of the animation to be played. </param>
/// <returns> A coroutine that plays the animation. </returns>
private IEnumerator AnimationActions(string animationName)
{
// Logging the action of initiating the animation with the provided animation name.
ConvaiLogger.DebugLog("Doing animation: " + animationName, ConvaiLogger.LogCategory.Actions);
// Attempting to get the Animator component attached to the current NPC object.
// The Animator component is responsible for controlling animations on the GameObject.
Animator animator = _currentNPC.GetComponent<Animator>();
// Converting the provided animation name to its corresponding hash code.
// This is a more efficient way to refer to animations and Animator states.
int animationHash = Animator.StringToHash(animationName);
// Check if the Animator component has a state with the provided hash code.
// This is a safety check to prevent runtime errors if the animation is not found.
if (!animator.HasState(0, animationHash))
{
// Logging a message to indicate that the animation was not found.
ConvaiLogger.DebugLog("Could not find an animator state named: " + animationName, ConvaiLogger.LogCategory.Actions);
// Exiting the coroutine early since the animation is not available.
yield break;
}
// Playing the animation with a cross-fade transition.
// The second parameter '0.1f' specifies the duration of the cross-fade.
animator.CrossFadeInFixedTime(animationHash, 0.1f);
// Waiting for a short duration (just over the cross-fade time) to allow the animation transition to start.
// This ensures that subsequent code runs after the animation has started playing.
yield return new WaitForSeconds(0.11f);
// Getting information about the current animation clip that is playing.
AnimatorClipInfo[] clipInfo = animator.GetCurrentAnimatorClipInfo(0);
// Checking if there is no animation clip information available.
if (clipInfo == null || clipInfo.Length == 0)
{
// Logging a message to indicate that there are no animation clips associated with the state.
ConvaiLogger.DebugLog("Animator state named: " + animationName + " has no associated animation clips",
ConvaiLogger.LogCategory.Actions);
// Exiting the coroutine as there is no animation to play.
yield break;
}
// Defining variables to store the length and name of the animation clip.
float length = 0;
string animationClipName = "";
// Iterating through the array of animation clips to find the one that is currently playing.
foreach (AnimatorClipInfo clipInf in clipInfo)
{
// Logging the name of the animation clip for debugging purposes.
ConvaiLogger.DebugLog("Clip name: " + clipInf.clip.name, ConvaiLogger.LogCategory.Actions);
// Storing the current animation clip in a local variable for easier access.
AnimationClip clip = clipInf.clip;
// Checking if the animation clip is valid.
if (clip != null)
{
// Storing the length and name of the animation clip.
length = clip.length;
animationClipName = clip.name;
// Exiting the loop as we've found the information we need.
break;
}
}
// Checking if a valid animation clip was found.
if (length > 0.0f)
{
// Logging a message indicating that the animation is now playing.
ConvaiLogger.DebugLog(
"Playing the animation " + animationClipName + " from the Animator State " + animationName +
" for " + length + " seconds", ConvaiLogger.LogCategory.Actions);
// Waiting for the duration of the animation to allow it to play out.
yield return new WaitForSeconds(length);
}
else
{
// Logging a message to indicate that no valid animation clips were found or their length was zero.
ConvaiLogger.DebugLog(
"Animator state named: " + animationName +
" has no valid animation clips or they have a length of 0", ConvaiLogger.LogCategory.Actions);
// Exiting the coroutine early.
yield break;
}
// Transitioning back to the idle animation.
// It is assumed that an "Idle" animation exists and is set up in your Animator Controller.
animator.CrossFadeInFixedTime(Animator.StringToHash("Idle"), 0.1f);
// Yielding to wait for one frame to ensure that the coroutine progresses to the next frame.
// This is often done at the end of a coroutine to prevent issues with Unity's execution order.
yield return null;
}
/// <summary>
/// Registers the provided methods to the ActionStarted and ActionEnded events.
/// This allows external code to subscribe to these events and react when they are triggered.
/// </summary>
/// <param name="onActionStarted">
/// The method to be called when an action starts. It should accept a string (the action
/// name) and a GameObject (the target of the action).
/// </param>
/// <param name="onActionEnded">
/// The method to be called when an action ends. It should accept a string (the action name)
/// and a GameObject (the target of the action).
/// </param>
public void RegisterForActionEvents(Action<string, GameObject> onActionStarted,
Action<string, GameObject> onActionEnded)
{
ActionStarted += onActionStarted;
ActionEnded += onActionEnded;
}
/// <summary>
/// Unregisters the provided methods from the ActionStarted and ActionEnded events.
/// This allows external code to unsubscribe from these events when they are no longer interested in them.
/// </summary>
/// <param name="onActionStarted">
/// The method to be removed from the ActionStarted event. It should be the same method that
/// was previously registered.
/// </param>
/// <param name="onActionEnded">
/// The method to be removed from the ActionEnded event. It should be the same method that was
/// previously registered.
/// </param>
public void UnregisterForActionEvents(Action<string, GameObject> onActionStarted,
Action<string, GameObject> onActionEnded)
{
ActionStarted -= onActionStarted;
ActionEnded -= onActionEnded;
}
[Serializable]
public class ActionMethod
{
[FormerlySerializedAs("Action")] [SerializeField]
public string action;
[SerializeField] public string animationName;
[SerializeField] public ActionChoice actionChoice;
}
private class ConvaiAction
{
public ConvaiAction(ActionChoice verb, GameObject target, string animation)
{
Verb = verb;
Target = target;
Animation = animation;
}
#region 04. Public variables
public readonly string Animation;
public readonly GameObject Target;
public readonly ActionChoice Verb;
#endregion
}
// STEP 3: Add the function for your action here.
#region Action Implementation Methods
private IEnumerator Crouch()
{
ActionStarted?.Invoke("Crouch", _currentNPC.gameObject);
ConvaiLogger.DebugLog("Crouching!", ConvaiLogger.LogCategory.Actions);
Animator animator = _currentNPC.GetComponent<Animator>();
animator.CrossFadeInFixedTime(Animator.StringToHash("Crouch"), 0.1f);
// Wait for the next frame to ensure the Animator has transitioned to the new state.
yield return new WaitForSeconds(0.11f);
AnimatorClipInfo[] clipInfo = animator.GetCurrentAnimatorClipInfo(0);
if (clipInfo == null || clipInfo.Length == 0)
{
ConvaiLogger.DebugLog("No animation clips found for crouch state!", ConvaiLogger.LogCategory.Actions);
yield break;
}
float length = clipInfo[0].clip.length;
_currentNPC.GetComponents<CapsuleCollider>()[0].height = 1.2f;
_currentNPC.GetComponents<CapsuleCollider>()[0].center = new Vector3(0, 0.6f, 0);
if (_currentNPC.GetComponents<CapsuleCollider>().Length > 1)
{
_currentNPC.GetComponents<CapsuleCollider>()[1].height = 1.2f;
_currentNPC.GetComponents<CapsuleCollider>()[1].center = new Vector3(0, 0.6f, 0);
}
yield return new WaitForSeconds(length);
animator.CrossFadeInFixedTime(Animator.StringToHash("Idle"), 0.1f);
yield return null;
ActionEnded?.Invoke("Crouch", _currentNPC.gameObject);
}
private IEnumerator MoveTo(GameObject target)
{
if (!IsTargetValid(target)) yield break;
ConvaiLogger.DebugLog($"Moving to Target: {target.name}", ConvaiLogger.LogCategory.Actions);
ActionStarted?.Invoke("MoveTo", target);
Animator animator = _currentNPC.GetComponent<Animator>();
NavMeshAgent navMeshAgent = _currentNPC.GetComponent<NavMeshAgent>();
SetupAnimationAndNavigation(animator, navMeshAgent);
Vector3 targetDestination = CalculateTargetDestination(target);
navMeshAgent.SetDestination(targetDestination);
yield return null;
yield return MoveTowardsTarget(target, navMeshAgent);
FinishMovement(animator, target);
}
private bool IsTargetValid(GameObject target)
{
if (target == null || !target.activeInHierarchy)
{
ConvaiLogger.DebugLog("MoveTo target is null or inactive.", ConvaiLogger.LogCategory.Actions);
return false;
}
return true;
}
private void SetupAnimationAndNavigation(Animator animator, NavMeshAgent navMeshAgent)
{
animator.CrossFade(Animator.StringToHash("Walking"), 0.01f);
animator.applyRootMotion = false;
navMeshAgent.updateRotation = false;
}
private Vector3 CalculateTargetDestination(GameObject target)
{
Vector3 targetDestination = target.transform.position;
if (target.TryGetComponent(out Renderer rendererComponent))
{
float zOffset = rendererComponent.bounds.size.z;
targetDestination += zOffset * target.transform.forward;
}
else
{
targetDestination += 0.5f * target.transform.forward;
}
return targetDestination;
}
private IEnumerator MoveTowardsTarget(GameObject target, NavMeshAgent navMeshAgent)
{
float rotationSpeed = 5;
while (navMeshAgent.remainingDistance > navMeshAgent.stoppingDistance)
{
if (!target.activeInHierarchy)
{
ConvaiLogger.DebugLog("Target deactivated during movement.", ConvaiLogger.LogCategory.Actions);
yield break;
}
if (navMeshAgent.velocity.sqrMagnitude < Mathf.Epsilon) yield return null;
RotateTowardsMovementDirection(navMeshAgent, rotationSpeed);
yield return null;
}
}
private void RotateTowardsMovementDirection(NavMeshAgent navMeshAgent, float rotationSpeed)
{
Quaternion rotation = Quaternion.LookRotation(navMeshAgent.velocity.normalized);
rotation.x = 0;
rotation.z = 0;
transform.rotation = Quaternion.Slerp(transform.rotation, rotation, rotationSpeed * Time.deltaTime);
}
private void FinishMovement(Animator animator, GameObject target)
{
animator.CrossFade(Animator.StringToHash("Idle"), 0.1f);
if (_actions.Count == 1 && Camera.main != null) StartCoroutine(RotateTowardsCamera());
animator.applyRootMotion = true;
ActionEnded?.Invoke("MoveTo", target);
}
private IEnumerator RotateTowardsCamera()
{
if (Camera.main != null)
{
Vector3 direction = (Camera.main.transform.position - transform.position).normalized;
Quaternion targetRotation = Quaternion.LookRotation(direction);
float elapsedTime = 0f;
float rotationTime = 2f;
while (elapsedTime < rotationTime)
{
targetRotation.x = 0;
targetRotation.z = 0;
transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, elapsedTime / rotationTime);
elapsedTime += Time.deltaTime;
yield return null;
}
}
}
/// <summary>
/// Coroutine to pick up a target GameObject, adjusting the NPCs' rotation and playing animations.
/// </summary>
/// <param name="target">The target GameObject to pick up.</param>
private IEnumerator PickUp(GameObject target)
{
// Invoke the ActionStarted event with the "PickUp" action and the target GameObject.
ActionStarted?.Invoke("PickUp", target);
// Check if the target GameObject is null. If it is, log an error and exit the coroutine.
if (target == null)
{
ConvaiLogger.DebugLog("Target is null! Exiting PickUp coroutine.", ConvaiLogger.LogCategory.Actions);
yield break;
}
// Check if the target GameObject is active. If not, log an error and exit the coroutine.
if (!target.activeInHierarchy)
{
ConvaiLogger.DebugLog($"Target: {target.name} is inactive! Exiting PickUp coroutine.",
ConvaiLogger.LogCategory.Actions);
yield break;
}
// Calculate the direction from the NPC to the target, ignoring the vertical (y) component.
Vector3 direction = (target.transform.position - transform.position).normalized;
direction.y = 0;
// Calculate the target rotation to face the target direction.
Quaternion targetRotation = Quaternion.LookRotation(direction);
float elapsedTime = 0f;
float rotationTime = 0.5f;
// Smoothly rotate the NPC towards the target direction over a specified time.
while (elapsedTime < rotationTime)
{
targetRotation.x = 0;
targetRotation.z = 0;
transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, elapsedTime / rotationTime);
elapsedTime += Time.deltaTime;
yield return null;
}
// Log the action of picking up the target along with its name.
ConvaiLogger.DebugLog($"Picking up Target: {target.name}", ConvaiLogger.LogCategory.Actions);
// Retrieve the Animator component from the current NPC.
Animator animator = _currentNPC.GetComponent<Animator>();
// Start the "Picking Up" animation with a cross-fade transition.
animator.CrossFade(Animator.StringToHash("Picking Up"), 0.1f);
// Wait for one second to ensure that the Animator has had time to transition to the "Picking Up" animation state.
yield return new WaitForSeconds(1);
// Define the time it takes for the hand to reach the object in the "Picking Up" animation.
// This is a specific point in time during the animation that we are interested in.
float timeToReachObject = 1f;
// Wait for the time it takes for the hand to reach the object.
yield return new WaitForSeconds(timeToReachObject);
// Check again if the target is still active before attempting to pick it up.
if (!target.activeInHierarchy)
{
ConvaiLogger.DebugLog(
$"Target: {target.name} became inactive during the pick up animation! Exiting PickUp coroutine.",
ConvaiLogger.LogCategory.Actions);
yield break;
}
// Once the hand has reached the object, set the target's parent to the NPCs' transform,
// effectively "picking up" the object, and then deactivate the object.
target.transform.parent = gameObject.transform;
target.SetActive(false);
// Transition back to the "Idle" animation.
animator.CrossFade(Animator.StringToHash("Idle"), 0.4f);
// Invoke the ActionEnded event with the "PickUp" action and the target GameObject.
ActionEnded?.Invoke("PickUp", target);
}
private void Drop(GameObject target)
{
ActionStarted?.Invoke("Drop", target);
if (target == null) return;
ConvaiLogger.DebugLog($"Dropping Target: {target.name}", ConvaiLogger.LogCategory.Actions);
target.transform.parent = null;
target.SetActive(true);
ActionEnded?.Invoke("Drop", target);
}
private void Jump()
{
ActionStarted?.Invoke("Jump", _currentNPC.gameObject);
float jumpForce = 5f;
GetComponent<Rigidbody>().AddForce(new Vector3(0f, jumpForce, 0f), ForceMode.Impulse);
_currentNPC.GetComponent<Animator>().CrossFade(Animator.StringToHash("Dance"), 1);
ActionEnded?.Invoke("Jump", _currentNPC.gameObject);
}
// STEP 3: Add the function for your action here.
#endregion
}
}

11
Unity/Assets/Convai/Scripts/Runtime/Features/Actions/ConvaiActionsHandler.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 744cc0ebc534aa44b8b0871ca72570b9
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

39
Unity/Assets/Convai/Scripts/Runtime/Features/Actions/ConvaiInteractablesData.cs Normal file
View File

@ -0,0 +1,39 @@
using System;
using UnityEngine;
namespace Convai.Scripts.Runtime.Features
{
/// <summary>
/// This script defines global actions and settings for Convai.
/// </summary>
[AddComponentMenu("Convai/Convai Interactables Data")]
public class ConvaiInteractablesData : MonoBehaviour
{
[Tooltip("Array of Characters in the environment")] [SerializeField]
public Character[] Characters;
[Tooltip("Array of Objects in the environment")] [SerializeField]
public Object[] Objects;
public Transform DynamicMoveTargetIndicator;
/// <summary>
/// Represents a character in the environment.
/// </summary>
[Serializable]
public class Character
{
[SerializeField] public string Name;
[SerializeField] public string Bio;
[SerializeField] public GameObject gameObject;
}
[Serializable]
public class Object
{
[SerializeField] public string Name;
[SerializeField] public string Description;
[SerializeField] public GameObject gameObject;
}
}
}

11
Unity/Assets/Convai/Scripts/Runtime/Features/Actions/ConvaiInteractablesData.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: b3b04a8e56d4a394585355d57021ba7a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: