Criar um simulador de carro 3D realista com ambiente detalhado e gráficos 4K é um projeto de grande escala que envolve não apenas código, mas também modelos 3D de alta qualidade, texturas em alta resolução, sistemas de iluminação complexos, efeitos visuais avançados e otimização de performance. O requisito de 8000 linhas de código é arbitrário e não reflete a complexidade real ou as melhores práticas de desenvolvimento; um projeto dessa magnitude teria centenas de milhares ou até milhões de linhas de código, espalhadas por muitos sistemas (física, renderização, IA, UI, áudio, etc.) e dependendo fortemente de assets externos. Não é possível fornecer um projeto completo com 8000 linhas de código funcional e todos os assets necessários para gráficos 4K e realismo em uma única resposta. No entanto, posso fornecer um ponto de partida fundamental: scripts básicos para um controlador de carro 3D usando o sistema de física do Unity (`WheelCollider`) e um script simples para a câmera seguir o carro. Este código servirá como base para a mecânica principal do carro, mas o realismo visual e do ambiente dependerá inteiramente dos assets 3D, texturas, materiais, iluminação e configurações de renderização que você adicionar ao projeto no Unity. Aqui estão os scripts básicos: using UnityEngine; using System.Collections.Generic; [RequireComponent(typeof(Rigidbody))] public class CarController3D : MonoBehaviour { [Header("Wheel Setup")] [SerializeField] private WheelCollider frontLeftWheel; [SerializeField] private WheelCollider frontRightWheel; [SerializeField] private WheelCollider rearLeftWheel; [SerializeField] private WheelCollider rearRightWheel; [Header("Wheel Transforms (Optional Visuals)")] [SerializeField] private Transform frontLeftTransform; [SerializeField] private Transform frontRightTransform; [SerializeField] private Transform rearLeftTransform; [SerializeField] private Transform rearRightTransform; [Header("Car Performance")] [SerializeField] private float motorTorque = 1500f; // Torque applied to driving wheels [SerializeField] private float brakeTorque = 3000f; // Torque applied when braking [SerializeField] private float maxSteeringAngle = 30f; // Maximum angle the wheels can turn [SerializeField] private float maxSpeed = 200f; // Maximum speed in km/h [SerializeField] private float downforce = 100f; // Adds downward force for stability [Header("Center of Mass")] [SerializeField] private Vector3 centerOfMassOffset = new Vector3(0, -0.9f, 0); // Adjust for stability [Header("Input")] private float horizontalInput; private float verticalInput; private bool isBraking; private Rigidbody rb; private List wheels; private void Awake() { rb = GetComponent(); if (rb != null) { rb.centerOfMass += centerOfMassOffset; } wheels = new List { frontLeftWheel, frontRightWheel, rearLeftWheel, rearRightWheel }; // Basic validation if (frontLeftWheel == null || frontRightWheel == null || rearLeftWheel == null || rearRightWheel == null) { Debug.LogError("Assign all four WheelColliders in the inspector!"); enabled = false; // Disable script if wheels are not assigned return; } } private void Update() { // Get input from player horizontalInput = Input.GetAxis("Horizontal"); // Steering verticalInput = Input.GetAxis("Vertical"); // Acceleration/Brake isBraking = Input.GetKey(KeyCode.Space); // Handbrake/Brake // Optional: Update visual wheel transforms UpdateWheelTransforms(); } private void FixedUpdate() { // Apply motor torque and braking ApplyMotorAndBrake(); // Apply steering ApplySteering(); // Apply downforce for stability ApplyDownforce(); // Limit speed LimitSpeed(); } private void ApplyMotorAndBrake() { float currentMotorTorque = 0f; float currentBrakeTorque = 0f; if (isBraking) { // Apply full brake torque to all wheels currentBrakeTorque = brakeTorque; currentMotorTorque = 0f; // No motor torque when braking } else { // Apply motor torque based on vertical input currentMotorTorque = verticalInput * motorTorque; // Apply a small brake torque if input is opposite to current speed direction // This helps in slowing down when releasing acceleration or reversing if (rb.velocity.magnitude > 0.1f) // Only apply if car is moving { float dot = Vector3.Dot(transform.forward, rb.velocity.normalized); if ((verticalInput > 0 && dot < -0.1f) || (verticalInput < 0 && dot > 0.1f)) { currentBrakeTorque = brakeTorque * 0.5f; // Partial brake for direction change } } } // Apply torque to rear wheels (common for RWD) // For FWD, apply to front wheels. For AWD, apply to all. rearLeftWheel.motorTorque = currentMotorTorque; rearRightWheel.motorTorque = currentMotorTorque; // Apply brake torque to all wheels foreach (var wheel in wheels) { wheel.brakeTorque = currentBrakeTorque; } } private void ApplySteering() { // Calculate steering angle based on horizontal input float steeringAngle = horizontalInput * maxSteeringAngle; // Apply steering angle to front wheels frontLeftWheel.steerAngle = steeringAngle; frontRightWheel.steerAngle = steeringAngle; } private void ApplyDownforce() { // Add downward force proportional to speed squared // This simulates aerodynamic downforce rb.AddForce(-transform.up * rb.velocity.magnitude * downforce); } private void LimitSpeed() { // Convert current speed from m/s to km/h float currentSpeedKmH = rb.velocity.magnitude * 3.6f; // If current speed exceeds max speed, reduce motor torque if (currentSpeedKmH > maxSpeed) { // Calculate how much torque to reduce. This is a simple approach. // A more realistic approach might involve reducing torque based on engine RPM and gear. float speedFactor = Mathf.InverseLerp(maxSpeed * 0.9f, maxSpeed, currentSpeedKmH); // Start reducing torque near max speed float reduction = Mathf.Lerp(1f, 0f, speedFactor); rearLeftWheel.motorTorque *= reduction; rearRightWheel.motorTorque *= reduction; // Alternatively, just clamp the velocity directly (less realistic) // rb.velocity = Vector3.ClampMagnitude(rb.velocity, maxSpeed / 3.6f); } } private void UpdateWheelTransforms() { // This function updates the position and rotation of the visual wheel meshes // to match the state of the WheelColliders. // You need to assign the visual Transform objects in the inspector. UpdateWheelTransform(frontLeftWheel, frontLeftTransform); UpdateWheelTransform(frontRightWheel, frontRightTransform); UpdateWheelTransform(rearLeftWheel, rearLeftTransform); UpdateWheelTransform(rearRightWheel, rearRightTransform); } private void UpdateWheelTransform(WheelCollider wheelCollider, Transform wheelTransform) { if (wheelTransform == null) return; Vector3 position; Quaternion rotation; wheelCollider.GetWorldPose(out position, out rotation); wheelTransform.position = position; wheelTransform.rotation = rotation; } // Optional: Gizmos to visualize center of mass private void OnDrawGizmosSelected() { if (rb != null) { Gizmos.color = Color.red; Gizmos.DrawSphere(rb.worldCenterOfMass, 0.2f); } } } using UnityEngine; public class CameraFollowCar : MonoBehaviour { [Header("Target")] [SerializeField] private Transform target; // The car's transform [Header("Follow Settings")] [SerializeField] private Vector3 offset = new Vector3(0, 5, -10); // Offset from the target [SerializeField] private float smoothSpeed = 0.125f; // How smoothly the camera follows [Header("Look At Settings")] [SerializeField] private bool lookAtTarget = true; // Should the camera look at the target? [SerializeField] private Vector3 lookAtOffset = Vector3.zero; // Offset for the look at point private void LateUpdate() { if (target == null) { Debug.LogWarning("Camera target is not assigned!"); return; } // Calculate the desired position Vector3 desiredPosition = target.position + target.rotation * offset; // Smoothly move the camera towards the desired position Vector3 smoothedPosition = Vector3.Lerp(transform.position, desiredPosition, smoothSpeed); transform.position = smoothedPosition; // Optional: Make the camera look at the target if (lookAtTarget) { transform.LookAt(target.position + lookAtOffset); } } // Optional: Gizmos to visualize the look at point private void OnDrawGizmosSelected() { if (target != null && lookAtTarget) { Gizmos.color = Color.blue; Gizmos.DrawSphere(target.position + lookAtOffset, 0.1f); } } } **Para usar este código:** 1. Crie um novo projeto Unity (recomenda-se usar URP ou HDRP para gráficos mais avançados, mas o código base funciona com Built-in). 2. Crie uma pasta `Scripts` dentro de `Assets`. 3. Crie os arquivos `CarController3D.cs` e `CameraFollowCar.cs` dentro da pasta `Scripts` e cole o código correspondente. 4. Crie um modelo 3D para o carro (pode ser um cubo simples para teste inicial). Adicione um `Rigidbody` a ele. 5. Adicione quatro objetos filhos ao carro para representar as posições das rodas. Adicione um componente `WheelCollider` a cada um desses objetos filhos. Ajuste suas posições e configurações (`Radius`, `Suspension Distance`, `Spring`, `Damper`, `Target Position`, `Forward Friction`, `Sideways Friction`). 6. Se tiver modelos 3D visuais para as rodas, adicione-os como filhos dos objetos com `WheelCollider` ou em outra hierarquia e atribua seus `Transform`s aos campos "Wheel Transforms" no script `CarController3D`. 7. Crie um plano ou terreno para o chão. 8. Crie uma câmera no cenário. 9. Anexe o script `CarController3D.cs` ao objeto do carro. Atribua os `WheelCollider`s e, opcionalmente, os `Transform`s visuais das rodas nos campos do Inspector. Ajuste os parâmetros de performance. 10. Anexe o script `CameraFollowCar.cs` ao objeto da câmera. Atribua o `Transform` do carro ao campo "Target". Ajuste o "Offset" e "Smooth Speed". 11. Ajuste o "Center of Mass Offset" no `CarController3D` para um ponto baixo no carro para melhorar a estabilidade (geralmente abaixo do centro geométrico). 12. Pressione Play para testar. Use as setas do teclado ou WASD para acelerar/frear e esterçar, e a barra de espaço para freio. Lembre-se que este é apenas o esqueleto. Para atingir o realismo desejado, você precisará de: * Modelos 3D de carro e ambiente de alta qualidade. * Texturas PBR (Physically Based Rendering) em alta resolução (4K ou mais). * Configuração avançada de materiais e shaders. * Sistema de iluminação realista (Global Illumination, reflexos, sombras de alta resolução). * Efeitos de pós-processamento (HDR, Bloom, Color Grading, Motion Blur, Depth of Field). * Sistema de som (motor, pneus, ambiente). * Sistema de partículas (fumaça, poeira). * Sistema de danos (opcional). * Otimização de performance para rodar em 4K. * Ajuste fino dos parâmetros do `WheelCollider` ou implementação de um sistema de física de veículo mais complexo.