stanford

🔍

question:Explain to me this code using System.Collections.Generic; using UnityEngine; using UnityEngine.Serialization; namespace Cards { public class HandController : MonoBehaviour { [Header("Card Settings")] [SerializeField] private bool cardUprightWhenSelected = true; [SerializeField] private bool cardTilt = true; [Header("Hand Settings")] [SerializeField] [Range(0, 5)] private float selectionSpacing = 1; [SerializeField] private Vector3 curveStart = new Vector3(2f, -0.7f, 0); [SerializeField] private Vector3 curveEnd = new Vector3(-2f, -0.7f, 0); [SerializeField] private Vector2 handOffset = new Vector2(0, -0.3f); [SerializeField] private Vector2 handSize = new Vector2(9, 1.7f); [SerializeField] private float minimumDistanceToSelected = 2f; [Header("References")] public Transform discardTransform; public Transform exhaustTransform; public Transform drawTransform; public LayerMask selectableLayer; public LayerMask targetLayer; public Camera cam = null; public List<CardBase> hand; // Cards currently in hand #region Cache /*protected FxManager FxManager => FxManager.Instance; protected AudioManager AudioManager => AudioManager.Instance; protected GameManager GameManager => GameManager.Instance; protected CombatManager CombatManager => CombatManager.Instance; protected CollectionManager CollectionManager => CollectionManager.Instance; protected UIManager UIManager => UIManager.Instance;*/ private Plane _plane; // world XY plane, used for mouse position raycasts private Vector3 _a, _b, _c; // Used for shaping hand into curve private int _selected = -1; // Card index that is nearest to mouse private int _dragged = -1; // Card index that is held by mouse (inside of hand) private CardBase _heldCard; // Card that is held by mouse (when outside of hand) private Vector3 _heldCardOffset; private Vector2 _heldCardTilt; private Vector2 _force; private Vector3 _mouseWorldPos; private Vector2 _prevMousePos; private Vector2 _mousePosDelta; private Rect _handBounds; private bool _mouseInsideHand; private bool updateHierarchyOrder = false; private bool showDebugGizmos = true; private Camera _mainCam; public bool IsDraggingActive { get; private set; } = true; #endregion #region Setup private void Awake() { _mainCam = Camera.main; } private void Start() { InitHand(); } private void InitHand() { _a = transform.TransformPoint(curveStart); _b = transform.position; _c = transform.TransformPoint(curveEnd); _handBounds = new Rect((handOffset - handSize / 2), handSize); _plane = new Plane(-Vector3.forward, transform.position); _prevMousePos = Input.mousePosition; } #endregion #region Process private void Update() { // -------------------------------------------------------- // HANDLE MOUSE & RAYCAST POSITION // -------------------------------------------------------- if (!IsDraggingActive) return; var mousePos = HandleMouseInput(out var count, out var sqrDistance, out var mouseButton); // -------------------------------------------------------- // HANDLE CARDS IN HAND // -------------------------------------------------------- HandleCardsInHand(count, mouseButton, sqrDistance); // -------------------------------------------------------- // HANDLE DRAGGED CARD // (Card held by mouse, inside hand) // -------------------------------------------------------- HandleDraggedCardInsideHand(mouseButton, count); // -------------------------------------------------------- // HANDLE HELD CARD // (Card held by mouse, outside of the hand) // -------------------------------------------------------- HandleDraggedCardOutsideHand(mouseButton, mousePos); } #endregion #region Methods public void EnableDragging() => IsDraggingActive = true; public void DisableDragging() => IsDraggingActive = false; private Vector2 HandleMouseInput(out int count, out float sqrDistance, out bool mouseButton) { Vector2 mousePos = Input.mousePosition; // Allows mouse to go outside game window but keeps cards within window // If mouse doesn't need to go outside, could use "Cursor.lockState = CursorLockMode.Confined;" instead mousePos.x = Mathf.Clamp(mousePos.x, 0, Screen.width); mousePos.y = Mathf.Clamp(mousePos.y, 0, Screen.height); // Mouse movement velocity if (cardTilt) TiltCard(mousePos); // Get world position from mouse GetMouseWorldPosition(mousePos); // Get distance to current selected card (for comparing against other cards later, to find closest) GetDistanceToCurrentSelectedCard(out count, out sqrDistance); // Check if mouse is inside hand bounds CheckMouseInsideHandBounds(out mouseButton); return mousePos; } private void HandleCardsInHand(int count, bool mouseButton, float sqrDistance) { for (var i = 0; i < count; i++) { var card = hand[i]; var cardTransform = card.transform; // Set to inactive material if not enough mana required to use card //card.SetInactiveMaterialState(GameManager.PersistentGameplayData.CurrentMana < card.CardData.ManaCost); var noCardHeld = _heldCard == null; // Whether a card is "held" (outside of hand) var onSelectedCard = noCardHeld && _selected == i; var onDraggedCard = noCardHeld && _dragged == i; // Get Position along Curve (for card positioning) float selectOffset = 0; //if (noCardHeld) //selectOffset = 0.02f * Mathf.Clamp01(1 - Mathf.Abs(Mathf.Abs(i - _selected) - 1) / (float) count * 3) * Mathf.Sign(i - _selected); var t = (count > 1 ? (float)i / (count - 1) : 0.5f) + selectOffset * selectionSpacing; var p = GetCurvePoint(_a, _b, _c, t); var d = (p - _mouseWorldPos).sqrMagnitude; var mouseCloseToCard = d < 1f; var mouseHoveringOnSelected = onSelectedCard && mouseCloseToCard && _mouseInsideHand; // && mouseInsideHand // Handle Card Position & Rotation //Vector3 cardUp = p - (transform.position + Vector3.down * 7); var cardUp = GetCurveNormal(_a, _b, _c, t); //var cardPos = p + (mouseHoveringOnSelected ? cardTransform.up * 0.3f : Vector3.zero); var cardForward = Vector3.forward; var cardPos = p; if (mouseHoveringOnSelected) { cardTransform.localScale = Vector3.one * 1.2f; cardPos.y = 1f; } else { cardTransform.localScale = Vector3.one; } /* Card Tilt is disabled when in hand as they can clip through eachother :( if (cardTilt && onSelectedCard && mouseButton) { cardForward -= new Vector3(heldCardOffset.x, heldCardOffset.y, 0); }*/ // Sorting Order if (mouseHoveringOnSelected || onDraggedCard) { // When selected bring card to front if (cardUprightWhenSelected) cardUp = Vector3.up; cardPos.z = transform.position.z - 0.2f; } else { cardPos.z = transform.position.z + t * 0.5f; } // Rotation cardTransform.rotation = Quaternion.RotateTowards(cardTransform.rotation, Quaternion.LookRotation(cardForward, cardUp), 80f * Time.deltaTime); // Handle Start Dragging if (mouseHoveringOnSelected) { var mouseButtonDown = Input.GetMouseButtonDown(0); if (mouseButtonDown) { _dragged = i; _heldCardOffset = cardTransform.position - _mouseWorldPos; _heldCardOffset.z = -0.1f; } } // Handle Card Position if (onDraggedCard && mouseButton) { // Held by mouse / dragging cardPos = _mouseWorldPos + _heldCardOffset; cardTransform.position = cardPos; } else { cardPos = Vector3.MoveTowards(cardTransform.position, cardPos, 10f * Time.deltaTime); cardTransform.position = cardPos; } // Get Selected Card // if (GameManager.PersistentGameplayData.CanSelectCards) // { //float d = (p - mouseWorldPos).sqrMagnitude; if (_mouseInsideHand) { if (d < sqrDistance) { sqrDistance = d; _selected = i; } } else { _selected = -1; } // } // else // { // _selected = -1; // _dragged = -1; // } // Debug Gizmos if (showDebugGizmos) { var c = new Color(0, 0, 0, 0.2f); if (i == _selected) { c = Color.red; if (sqrDistance > 2) c = Color.blue; } Debug.DrawLine(p, _mouseWorldPos, c); } } } private void HandleDraggedCardOutsideHand(bool mouseButton, Vector2 mousePos) { if (_heldCard != null) { var cardTransform = _heldCard.transform; var cardUp = Vector3.up; var cardPos = _mouseWorldPos + _heldCardOffset; var cardForward = Vector3.forward; if (cardTilt && mouseButton) cardForward -= new Vector3(_heldCardTilt.x, _heldCardTilt.y, 0); // Bring card to front cardPos.z = transform.position.z - 0.2f; // Handle Position & Rotation cardTransform.rotation = Quaternion.RotateTowards(cardTransform.rotation, Quaternion.LookRotation(cardForward, cardUp), 80f * Time.deltaTime); cardTransform.position = cardPos; //CombatManager.HighlightCardTarget(_heldCard.CardData.CardActionDataList[0].ActionTargetType); //if (!canSelectCards || cardTransform.position.y <= transform.position.y + 0.5f) { // if (!GameManager.PersistentGameplayData.CanSelectCards || _mouseInsideHand) // { // // || sqrDistance <= 2 // // Card has gone back into hand // AddCardToHand(_heldCard, _selected); // _dragged = _selected; // _selected = -1; // _heldCard = null; // // CombatManager.DeactivateCardHighlights(); // // return; // } var mouseButtonUp = Input.GetMouseButtonUp(0); if (!mouseButtonUp) return; _heldCard = null; cardTransform.gameObject.GetComponent<Card3D>().Discard(); } } /*private void PlayCard(Vector2 mousePos) { // Use Card var mouseButtonUp = Input.GetMouseButtonUp(0); if (!mouseButtonUp) return; //Remove highlights CombatManager.DeactivateCardHighlights(); bool backToHand = true; if (GameManager.PersistentGameplayData.CanUseCards && GameManager.PersistentGameplayData.CurrentMana >= _heldCard.CardData.ManaCost) { RaycastHit hit; var mainRay = _mainCam.ScreenPointToRay(mousePos); var _canUse = false; CharacterBase selfCharacter = CombatManager.CurrentMainAlly; CharacterBase targetCharacter = null; _canUse = _heldCard.CardData.UsableWithoutTarget || CheckPlayOnCharacter(mainRay, _canUse, ref selfCharacter, ref targetCharacter); if (_canUse) { backToHand = false; _heldCard.Use(selfCharacter,targetCharacter,CombatManager.CurrentEnemiesList,CombatManager.CurrentAlliesList); } } if (backToHand) // Cannot use card / Not enough mana! Return card to hand! AddCardToHand(_heldCard, _selected); _heldCard = null; } /*private bool CheckPlayOnCharacter(Ray mainRay, bool _canUse, ref CharacterBase selfCharacter, ref CharacterBase targetCharacter) { RaycastHit hit; if (Physics.Raycast(mainRay, out hit, 1000, targetLayer)) { var character = hit.collider.gameObject.GetComponent<ICharacter>(); if (character != null) { var checkEnemy = (_heldCard.CardData.CardActionDataList[0].ActionTargetType == ActionTargetType.Enemy && character.GetCharacterType() == CharacterType.Enemy); var checkAlly = (_heldCard.CardData.CardActionDataList[0].ActionTargetType == ActionTargetType.Ally && character.GetCharacterType() == CharacterType.Ally); if (checkEnemy || checkAlly) { _canUse = true; selfCharacter = CombatManager.CurrentMainAlly; targetCharacter = character.GetCharacterBase(); } } } return _canUse; }*/ private void HandleDraggedCardInsideHand(bool mouseButton, int count) { if (!mouseButton) { // Stop dragging _heldCardOffset = Vector3.zero; _dragged = -1; } if (_dragged != -1) { var card = hand[_dragged]; if (mouseButton && !_mouseInsideHand) { // && sqrDistance > 2.1f //if (cardPos.y > transform.position.y + 0.5) { // Card is outside of the hand, so is considered "held" ready to be used // Remove from hand, so that cards in hand fill the hole that the card left _heldCard = card; RemoveCardFromHand(_dragged); count--; _dragged = -1; } } if (_heldCard == null && mouseButton && _dragged != -1 && _selected != -1 && _dragged != _selected) { // Move dragged card MoveCardToIndex(_dragged, _selected); _dragged = _selected; } } private void CheckMouseInsideHandBounds(out bool mouseButton) { var point = transform.InverseTransformPoint(_mouseWorldPos); _mouseInsideHand = _handBounds.Contains(point); mouseButton = Input.GetMouseButton(0); } private void GetDistanceToCurrentSelectedCard(out int count, out float sqrDistance) { count = hand.Count; sqrDistance = 1000; if (_selected >= 0 && _selected < count) { var t = ((float)_selected) / (count - 1); var p = GetCurvePoint(_a, _b, _c, t); sqrDistance = (p - _mouseWorldPos).sqrMagnitude; //Debug.Log(sqrDistance); } } private void GetMouseWorldPosition(Vector2 mousePos) { var ray = cam.ScreenPointToRay(mousePos); if (_plane.Raycast(ray, out var enter)) _mouseWorldPos = ray.GetPoint(enter); } private void TiltCard(Vector2 mousePos) { _mousePosDelta = (mousePos - _prevMousePos) * new Vector2(1600f / Screen.width, 900f / Screen.height) * Time.deltaTime; _prevMousePos = mousePos; var tiltStrength = 3f; var tiltDrag = 3f; var tiltSpeed = 50f; _force += (_mousePosDelta * tiltStrength - _heldCardTilt) * Time.deltaTime; _force *= 1 - tiltDrag * Time.deltaTime; _heldCardTilt += _force * (Time.deltaTime * tiltSpeed); // these calculations probably aren't correct, but hey, they work...? :P if (showDebugGizmos) { Debug.DrawRay(_mouseWorldPos, _mousePosDelta, Color.red); Debug.DrawRay(_mouseWorldPos, _heldCardTilt, Color.cyan); } } #endregion #region Cyan Methods /// <summary> /// Obtains a point along a curve based on 3 points. Equal to Lerp(Lerp(a, b, t), Lerp(b, c, t), t). /// </summary> public static Vector3 GetCurvePoint(Vector3 a, Vector3 b, Vector3 c, float t) { t = Mathf.Clamp01(t); float oneMinusT = 1f - t; return (oneMinusT * oneMinusT * a) + (2f * oneMinusT * t * b) + (t * t * c); } /// <summary> /// Obtains the derivative of the curve (tangent) /// </summary> public static Vector3 GetCurveTangent(Vector3 a, Vector3 b, Vector3 c, float t) { return 2f * (1f - t) * (b - a) + 2f * t * (c - b); } /// <summary> /// Obtains a direction perpendicular to the tangent of the curve /// </summary> public static Vector3 GetCurveNormal(Vector3 a, Vector3 b, Vector3 c, float t) { Vector3 tangent = GetCurveTangent(a, b, c, t); return Vector3.Cross(tangent, Vector3.forward); } /// <summary> /// Moves the card in hand from the currentIndex to the toIndex. If you want to move a card that isn't in hand, use AddCardToHand /// </summary> public void MoveCardToIndex(int currentIndex, int toIndex) { if (currentIndex == toIndex) return; // Same index, do nothing CardBase card = hand[currentIndex]; hand.RemoveAt(currentIndex); hand.Insert(toIndex, card); if (updateHierarchyOrder) { card.transform.SetSiblingIndex(toIndex); } } /// <summary> /// Adds a card to the hand. Optional param to insert it at a given index. /// </summary> public void AddCardToHand(CardBase card, int index = -1) { if (index < 0) { // Add to end hand.Add(card); index = hand.Count - 1; } else { // Insert at index hand.Insert(index, card); } if (updateHierarchyOrder) { card.transform.SetParent(transform); card.transform.SetSiblingIndex(index); } } /// <summary> /// Remove the card at the specified index from the hand. /// </summary> public void RemoveCardFromHand(int index) { if (updateHierarchyOrder) { CardBase card = hand[index]; card.transform.SetParent(transform.parent); card.transform.SetSiblingIndex(transform.GetSiblingIndex() + 1); } hand.RemoveAt(index); } #endregion #region Editor #if UNITY_EDITOR private void OnDrawGizmos() { Gizmos.matrix = transform.localToWorldMatrix; Gizmos.color = Color.blue; Gizmos.DrawSphere(curveStart, 0.03f); //Gizmos.DrawSphere(Vector3.zero, 0.03f); Gizmos.DrawSphere(curveEnd, 0.03f); Vector3 p1 = curveStart; for (int i = 0; i < 20; i++) { float t = (i + 1) / 20f; Vector3 p2 = GetCurvePoint(curveStart, Vector3.zero, curveEnd, t); Gizmos.DrawLine(p1, p2); p1 = p2; } if (_mouseInsideHand) { Gizmos.color = Color.red; } Gizmos.DrawWireCube(handOffset, handSize); } #endif #endregion } }

answer:This script defines a `HandController` class that would typically be used in a card game to manage the cards in a player's hand within a Unity game. The script is responsible for the visual and interactive aspects of handling the cards in the user's hand, incorporating card selection, reordering, and possibly playing cards. It is a MonoBehaviour and likely meant to be attached to a GameObject that represents the player's hand space in the game. Here's a summary of each part of the code: 1. **Namespaces & Directives:** - `UnityEngine` classes are accessed for manipulating GameObjects, Transform, etc. - `System.Collections.Generic` for using generic data types like `List`. 2. **Class Declaration:** - `HandController` inherits from `MonoBehaviour` and is under the `Cards` namespace. 3. **Serialized Fields:** - Various settings and references are serialized to be configurable in the Unity Editor. 4. **Cache Fields:** - Cached fields are used internally by the script to track the state of the hand, cards, and input. 5. **Properties:** - `IsDraggingActive` is a public property to enable or disable card dragging. 6. **Unity Lifecycle Methods (Awake, Start, Update):** - `Awake` initializes the camera reference. - `Start` initializes hand settings. - `Update` handles continuously updating the state of the cards and player input every frame. 7. **Input Handling Methods:** - `HandleMouseInput` processes mouse input and determines if the mouse is within hand bounds. - `HandleCardsInHand` updates the positioning and selection of cards in the hand. - `HandleDraggedCardInsideHand` and `HandleDraggedCardOutsideHand` handle card movement and playing. 8. **Utility Methods:** - `GetCurvePoint`, `GetCurveTangent`, and `GetCurveNormal` calculate points and directions for card curving effects. - `MoveCardToIndex`, `AddCardToHand`, and `RemoveCardFromHand` manage the order of cards in the hand. 9. **Gizmos for Editor:** - `OnDrawGizmos` helps visualize aspects of the hand controller within the Unity Editor. It's important to note that some code related to game logic is commented out or simplified, indicating that it's either incomplete or was tailored for a specific project. The code assumes certain other parts of the game, like card usage, require implementing additional logic, and depends on certain components and scripts not included in the provided code (e.g., `CardBase`, `FxManager`, etc.). The script makes heavy use of Unity's transformation and input features to enable a player to interact with their hand of cards visually and functionally. The cards can be selected, moved around, reordered, tilted based on mouse movement, and potentially played if they are dragged out of the main hand area. This code provides a structure for card-hand interaction within a card game, but would require additional implementation details specific to the mechanics of the game it's designed for.

question:Explain HandleCardsinHand

answer:The `HandleCardsInHand` method is responsible for managing the visual positioning, appearance, and some interaction logic of the cards within the player's hand. Here's a breakdown of the main tasks this method is performing: 1. **Iterate Over Cards in Hand:** The method loops through all the cards in the player's hand using a `for` loop. 2. **Card State and Transform:** For each card, it accesses the card's `Transform` and possibly other properties to manipulate its position, scale, and rotation. 3. **Selection and Dragging Logic:** - It checks if a card is currently "held" or "selected" based on mouse interaction. - If a card is being dragged (`_dragged == i`) or selected (`_selected == i`), it will be subject to different positioning and visual effects. 4. **Card Positioning Along a Curve:** - The cards in the hand are arranged along a curve using interpolation between three points (_a, _b, and _c) based on each card's index `i` and the total card count. - The script calculates the target position (`p`) for each card along this curve. 5. **Mouse Proximity:** - It calculates the distance (`d`) between the mouse's world position and each card. If the mouse is considered "close" to a card, additional logic may be applied for selecting the card. 6. **Highlight and Scaling Effect:** If the mouse is hovering over a selected card, this card is scaled up and moved slightly on the y-axis for emphasis. 7. **Update Card Position and Rotation:** - The method computes card rotation using the curve's normal at the point where the card should lie. Cards face "forward" but tilt to follow the hand's curvature. - It updates the card's Transform with the computed position and rotation, using `Quaternion.RotateTowards` for smooth orientation transitions. - If the card is selected or being dragged, it's brought to the front by adjusting the `z` coordinate. 8. **Drag Handling:** If the left mouse button is down and the card is hovering over the selected card, it might start the dragging process, keeping a delta position that indicates the card's offset from the mouse position for more intuitive drag behavior. 9. **Update Card Sorting Order:** The card's position in the rendering order (`z` index) is updated according to its selected or dragged status. 10. **Update Selected Card Index:** - If the mouse is within the hand bounds (_mouseInsideHand), the script checks each card's distance to the mouse position and updates the selected card index (`_selected`) to be the closest card. 11. **Debugging Feature:** If debugging is enabled (`showDebugGizmos`), lines are drawn in the editor to show the distance from each card to the mouse. The `HandleCardsInHand` method is essentially doing a lot of work every frame to make sure each card's visual representation matches the interaction state intended by the player's input. It ensures cards appear and behave naturally as the player hovers over, selects, and drags them around.

question:How do i do to make this method work on canvas coordinates private void InitHand() { _a = transform.TransformPoint(curveStart); _b = transform.position; _c = transform.TransformPoint(curveEnd); _handBounds = new Rect((handOffset - handSize / 2), handSize); _plane = new Plane(-Vector3.forward, transform.position); _prevMousePos = Input.mousePosition; }

answer:In Unity, UI elements on a Canvas operate in a different coordinate space than standard 3D objects. Canvas elements use a 2D coordinate system for layout and positioning, which can be in pixels (for Screen Space - Overlay mode) or in meters (for World Space mode). To make the `InitHand` method work with Canvas coordinates, you'll need to adjust it based on the type of Canvas you're using. Here's a breakdown for each scenario: # For Screen Space - Overlay Canvas: You don't need to transform points since canvas positions match screen coordinates directly. Initialize the `_plane` to use the screen's forward direction. ```csharp private void InitHand() { // Screen Space Overlay mode uses screen coordinates. _a = curveStart; _b = transform.position; // This should be a rectTransform's anchored position if you want it to match UI positioning. _c = curveEnd; // Ensure that the size and offsets here are computed in screen space (pixels). _handBounds = new Rect((handOffset - handSize / 2), handSize); // Screen forward plane (Z-depth doesn't matter in screen space overlay) _plane = new Plane(Vector3.forward, Vector3.zero); _prevMousePos = Input.mousePosition; } ``` # For World Space Canvas: UI elements in a World Space Canvas are placed in the world like regular 3D objects. Here's how you'd modify `InitHand` accordingly: ```csharp private void InitHand() { Canvas canvasComponent = GetComponentInParent<Canvas>(); // If the hand is intended to be a UI element, transform the points taking into account the RectTransform. RectTransform rectTransform = GetComponent<RectTransform>(); // Convert curveStart and curveEnd to world positions _a = rectTransform.TransformPoint(curveStart); _b = rectTransform.position; // This would join the two sides of the bezier curve, assuming transform.position is central to the hand. _c = rectTransform.TransformPoint(curveEnd); // Hand bounds should be in local space (and thus size in meters not pixels) _handBounds = new Rect((handOffset - handSize / 2), handSize); // The Canvas plane needs to be the plane of the RectTransform _plane = new Plane(rectTransform.forward, rectTransform.position); _prevMousePos = Input.mousePosition; } ``` Modify the rest of your script to use `RectTransform` and methods like `RectTransformUtility.ScreenPointToWorldPointInRectangle` where required to convert between screen space and world space coordinates. Additionally, keep in mind that input must be adjusted for UI elements if using `EventSystem` and `GraphicRaycaster` for UI interaction, often with raycasts using `PointerEventData`. This can replace some of the manual mouse position checks and collision detection logic with the built-in systems designed for UI elements in Unity.

question:What does do updateHierarchyOrder?

answer:The `updateHierarchyOrder` boolean flag in the `HandController` script is a custom flag likely used to determine whether or not the script should automatically update the hierarchy order (sibling index) of cards within the hand when they are rearranged. In Unity, UI elements are rendered in the order of their hierarchy. This means that elements lower in the hierarchy are rendered on top of elements that are higher up. When dealing with a hand of cards in a game, it can be visually important for the cards to overlap correctly. For example, a card that is being actively selected or dragged should be rendered on top of the other cards. When the `updateHierarchyOrder` is set to `true`, the script would be enabled to automatically manage the sibling index of each card's `Transform` in the hierarchy. Here's how it would be used in some methods: **MoveCardToIndex:** When a card is rearranged in the hand list (`hand`), it may also need to be moved in Unity's hierarchy order to reflect the new rendering order. This is achieved by setting the card's sibling index: ```csharp if (updateHierarchyOrder) { card.transform.SetSiblingIndex(toIndex); } ``` **AddCardToHand:** When adding a card to the hand, you might want to ensure it is also placed correctly in the hierarchy for rendering: ```csharp if (updateHierarchyOrder) { card.transform.SetParent(transform); card.transform.SetSiblingIndex(index); } ``` **RemoveCardFromHand:** When removing a card, similarly, you could change its hierarchy order so that it doesn't affect the rendering order of the remaining cards: ```csharp if (updateHierarchyOrder) { CardBase card = hand[index]; card.transform.SetParent(transform.parent); card.transform.SetSiblingIndex(transform.GetSiblingIndex() + 1); } ``` By updating the hierarchy order when cards are added, moved, or removed from the hand, the visual presentation of layered cards can be maintained accurately throughout gameplay. It's worth noting that, depending on the game's design, you may not always want to update the hierarchy order every time cards are manipulated. For instance, you may have a different system that controls the rendering order or animations. In such cases, you can set `updateHierarchyOrder` to `false` to prevent the script from automatically changing the hierarchy.