Arquiteto de Lógica de Física para Jogos

Atue como um Arquiteto de Lógica de Física de Jogos. Implemente a mecânica de gancho de escalada com tensão elástica e balanço por força centrífuga. **1. Fórmulas Matemáticas (LaTeX)** - **Tensão Elástica da Corda (Lei de Hooke com amortecimento):** \[ F_{tensão} = -k \cdot (L_{atual} - L_{descanso}) - c \cdot \dot{L}_{atual} \] Onde \( k \) é a rigidez da corda, \( c \) é o coeficiente de amortecimento, \( L_{atual} \) é o comprimento atual, \( L_{descanso} \) é o comprimento natural, e \( \dot{L}_{atual} \) é a taxa de variação do comprimento. - **Força Centrífuga (Componente radial da aceleração):** \[ F_{centrífuga} = m \cdot \frac{v_{tangencial}^2}{r} \] Onde \( m \) é a massa do jogador, \( v_{tangencial} \) é a velocidade perpendicular ao vetor da corda, e \( r \) é o raio (distância do pivô ao jogador). - **Integração de Velocidade (Semi-implícita de Euler):** \[ v_{novo} = v_{atual} + (F_{gravidade} + F_{tensão} + F_{centrífuga}) \cdot \Delta t \] \[ p_{novo} = p_{atual} + v_{novo} \cdot \Delta t \] - **Latência de Entrada (Filtro de resposta com predição):** \[ t_{resposta} = t_{entrada} + \frac{d_{erro}}{v_{máx}} \cdot \alpha \] Onde \( d_{erro} \) é a distância entre o ponto de mira e o ponto de ancoragem, \( v_{máx} \) é a velocidade máxima de projétil, e \( \alpha \) é um fator de compensação (0.1 a 0.3). **2. Diagrama de Máquina de Estados (Markdown)** ```mermaid stateDiagram-v2 [*] --> Idle Idle --> Aiming: InputPrimario (hold) Aiming --> Firing: InputPrimario (release) Firing --> RopeActive: ColisãoDetectada Firing --> Idle: SemColisão (tempo limite) RopeActive --> Swinging: InputSecundario (hold) Swinging --> RopeActive: InputSecundario (release) RopeActive --> Retracting: InputTerciario (tap) Retracting --> RopeActive: ComprimentoMínimo RopeActive --> Idle: InputPrimario (release) OU DistânciaMáxima Swinging --> Idle: InputPrimario (release) ``` **3. Código de Produção (C# para Unity)** ```csharp using UnityEngine; public class GrappleHookPhysics : MonoBehaviour { [Header("Parâmetros da Corda")] [SerializeField] private float springStiffness = 100f; [SerializeField] private float damping = 5f; [SerializeField] private float restLength = 2f; [SerializeField] private float maxLength = 20f; [Header("Parâmetros do Jogador")] [SerializeField] private float playerMass = 70f; [SerializeField] private float gravity = 9.81f; [SerializeField] private float maxTangentialSpeed = 15f; [Header("Referências")] [SerializeField] private Transform playerTransform; [SerializeField] private LineRenderer ropeRenderer; private Vector3 anchorPoint; private Vector3 currentVelocity; private bool isRopeActive = false; private bool isSwinging = false; private void Update() { HandleInput(); if (isRopeActive) { ApplyPhysics(); UpdateRopeVisual(); } } private void HandleInput() { if (Input.GetMouseButtonDown(0) && !isRopeActive) { TryFireGrapple(); } if (Input.GetMouseButtonUp(0) && isRopeActive) { ReleaseRope(); } if (Input.GetMouseButton(1) && isRopeActive) { isSwinging = true; } else { isSwinging = false; } } private void TryFireGrapple() { Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); if (Physics.Raycast(ray, out RaycastHit hit, maxLength)) { anchorPoint = hit.point; isRopeActive = true; currentVelocity = Vector3.zero; ropeRenderer.enabled = true; } } private void ApplyPhysics() { Vector3 ropeVector = playerTransform.position - anchorPoint; float currentLength = ropeVector.magnitude; // Lei de Hooke com amortecimento float lengthRate = Vector3.Dot(currentVelocity, ropeVector.normalized); float springForceMagnitude = -springStiffness * (currentLength - restLength) - damping * lengthRate; Vector3 springForce = ropeVector.normalized * springForceMagnitude; // Força centrífuga (componente tangencial) Vector3 tangentialVelocity = currentVelocity - Vector3.Project(currentVelocity, ropeVector.normalized); float tangentialSpeed = tangentialVelocity.magnitude; float centrifugalForceMagnitude = playerMass * (tangentialSpeed * tangentialSpeed) / Mathf.Max(currentLength, 0.1f); Vector3 centrifugalForce = ropeVector.normalized * centrifugalForceMagnitude; // Gravidade Vector3 gravityForce = Vector3.down * playerMass * gravity; // Integração semi-implícita de Euler Vector3 totalForce = springForce + centrifugalForce + gravityForce; Vector3 acceleration = totalForce / playerMass; currentVelocity += acceleration * Time.deltaTime; // Limite de velocidade tangencial Vector3 newTangential = currentVelocity - Vector3.Project(currentVelocity, ropeVector.normalized); if (newTangential.magnitude > maxTangentialSpeed) { newTangential = newTangential.normalized * maxTangentialSpeed; currentVelocity = newTangential + Vector3.Project(currentVelocity, ropeVector.normalized); } // Atualizar posição playerTransform.position += currentVelocity * Time.deltaTime; // Restrição de comprimento máximo Vector3 newRopeVector = playerTransform.position - anchorPoint; if (newRopeVector.magnitude > maxLength) { playerTransform.position = anchorPoint + newRopeVector.normalized * maxLength; currentVelocity -= Vector3.Project(currentVelocity, newRopeVector.normalized); } } private void ReleaseRope() { isRopeActive = false; isSwinging = false; ropeRenderer.enabled = false; } private void UpdateRopeVisual() { ropeRenderer.SetPosition(0, anchorPoint); ropeRenderer.SetPosition(1, playerTransform.position); } } ```