Развитие гоночек

Assets/Code/Example/Race/RaceGame.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using Code.Example.Race.Racer;
+using Code.Example.Race.Track;
+using Code.Infrastructure.EventBus;
+using Code.Infrastructure.Loadings;
+using Reflex.Attributes;
+
+namespace Code.Example.Race
+{
+    public class RaceGame : IRacerLoadedHandle, IDisposable
+    {
+        private RaceScores _scores;
+        
+        private IRacerFactory _racerFactory;
+        private RaceTrackData _raceTrackData;
+        private EventBus _eventBus;
+
+        public RaceGame(EventBus eventBus, IRacerFactory racerFactory, RaceTrackData raceTrackData, RaceScores scores)
+        {
+            _eventBus = eventBus;
+            _racerFactory = racerFactory;
+            _raceTrackData = raceTrackData;
+            _eventBus.Subscribe(this);
+
+            _scores = scores;
+            
+            RandomizeRacers(raceTrackData.trackData.RacerPoints.Count);
+        }
+
+        public void StartRacers()
+        {
+            foreach (var racer in PlacedRacers)
+            {
+                racer.StartRacer();
+            }
+        }
+
+        // DEBUG
+        private List<RacerType> _randomizedTypes = new();
+
+        private void RandomizeRacers(int count)
+        {
+            _raceGameLoading = new Loading(count, RacersLoadCompleted);
+
+            _randomizedTypes.Add(RacerType.Player);
+
+            for (var i = 0; i < count - 1; i++)
+                _randomizedTypes.Add((RacerType)UnityEngine.Random.Range(1, 3));
+
+            foreach (var type in _randomizedTypes) _racerFactory.LoadRacer(type);
+        }
+
+        private void RacersLoadCompleted() =>
+            _eventBus.RaiseEvent<IRaceGameInitializedHandle>(x => x.RaceGameReady());
+
+        public List<Racer.AI.Racer> PlacedRacers { get; } = new();
+
+        public void PlaceRacers()
+        {
+            for (var i = 0; i < _raceTrackData.trackData.RacerPoints.Count; i++)
+            {
+                PlacedRacers.Add(UnityEngine.Object.Instantiate(
+                    _racerPrefabs[_randomizedTypes[i]],
+                    _raceTrackData.trackData.RacerPoints[i].transform).GetComponent<Racer.AI.Racer>());
+                PlacedRacers[^1].SetData(_racerPrefabs[_randomizedTypes[i]].Data);
+                PlacedRacers[^1].Id = i;
+                _scores.SubscribeRacer(i);
+            }
+
+            foreach (var racer in PlacedRacers)
+            {
+                racer.Initialize(_raceTrackData.trackData.Checkpoints);
+            }
+        }
+
+        private Dictionary<RacerType, Racer.AI.Racer> _racerPrefabs = new();
+        private Loading _raceGameLoading;
+
+        public void RacerLoaded(RacerType type, Racer.AI.Racer racer)
+        {
+            if (racer)
+                _racerPrefabs.Add(type, racer);
+            
+            _raceGameLoading.DoProgress();
+        }
+
+        // private Dictionary<RacerType, Racer.AI.Racer> _spawnedRacers = new();
+        public void RacerCreated(RacerType type, Racer.AI.Racer racer)
+        {
+            // _spawnedRacers.Add(type, racer);
+            // _raceGameLoading.DoProgress();
+        }
+
+        public void Dispose()
+        {
+            _eventBus.Unsubscribe(this);
+            _racerPrefabs.Clear();
+        }
+    }
+
+    public interface IRaceGameInitializedHandle : IGlobalSubscriber
+    {
+        void RaceGameReady();
+    }
+}

Assets/Code/Example/Race/RaceGame.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0ffa5c181be7447cb1c41392018b193f
+timeCreated: 1769692114

Assets/Code/Example/Race/RaceScores.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Code.Example.Race.Track;
+using Code.Infrastructure.EventBus;
+
+namespace Code.Example.Race
+{
+    public class RaceScores : IRacerPassedCheckpointHandler, IDisposable
+    {
+        private Dictionary<int, int> _scores = new();
+        private EventBus _eventBus;
+
+        public RaceScores(EventBus eventBus)
+        {
+            _eventBus = eventBus;
+            _eventBus.Subscribe(this);
+        }
+        public void SubscribeRacer(int racer)
+        {
+            _scores.Add(racer, 0);
+        }
+
+        public void ChangeScore(int racer, int additionalScore)
+        {
+            _scores[racer] += additionalScore;
+            _eventBus.RaiseEvent<IScoreChangedHandle>(x=> x.ScoreChanged(racer,additionalScore, GetScores()));
+        }
+        
+        public void UnsubscribeRacer(int racer)
+        {
+            _scores.Remove(racer);
+        }
+
+        public List<KeyValuePair<int, int>> GetScores()
+        {
+            return _scores.OrderByDescending(x => x.Value).ToList();
+        }
+
+        public void OnRacerPassedCheckpoint(Racer.AI.Racer racer) => ChangeScore(racer.Id,1);
+
+        public void Dispose()
+        {
+            _eventBus.Unsubscribe(this);
+        }
+    }
+
+    public interface IScoreChangedHandle : IGlobalSubscriber
+    {
+        void ScoreChanged(int racer, int additionalScore, List<KeyValuePair<int, int>> scores);
+    }
+}

Assets/Code/Example/Race/RaceScores.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b45fb028abcf43129f5c8100e7215f1f
+timeCreated: 1770051193

Assets/Code/Example/Race/Racer/AI/AIDebugRacer.cs

@@ -4,7 +4,7 @@ using UnityEngine.AI;
 
 namespace Code.Example.Race.Racer.AI
 {
-    public class AIDebugRacer : MonoBehaviour
+    public class AIDebugRacer : Racer
     {
         [SerializeField] private NavMeshAgent navMeshAgent;
         [SerializeField] private List<Transform> waypoints;
@@ -15,11 +15,31 @@ namespace Code.Example.Race.Racer.AI
             _currentWaypointIndex++;
         }
 
-        public void NextWaypoint()
+        public override void NextWaypoint()
         {
             if(_currentWaypointIndex >= waypoints.Count) _currentWaypointIndex = 0;
             
             navMeshAgent.destination = waypoints[_currentWaypointIndex++].position;
         }
+
+        public override void StartRacer()
+        {
+            
+        }
+
+        public override void StopRacer()
+        {
+            
+        }
+
+        public override void SetData(RacerData data)
+        {
+            
+        }
+
+        public override void Initialize(List<Transform> waypoints)
+        {
+            
+        }
     }
 }

Assets/Code/Example/Race/Racer/AI/AIRacer.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.AI;
+
+namespace Code.Example.Race.Racer.AI
+{
+    public class AIRacer : Racer
+    {
+        [SerializeField] private NavMeshAgent navMeshAgent;
+
+        public override void SetData(RacerData data)
+        {
+            Data = data;
+            navMeshAgent.angularSpeed = data.angularSpeed;
+            navMeshAgent.speed = data.speed;
+        }
+
+        public override void Initialize(List<Transform> waypoints)
+        {
+            navMeshAgent.isStopped = true;
+            
+            Waypoints = waypoints;
+            navMeshAgent.destination = Waypoints[CurrentWaypointIndex].position;
+            
+            CurrentWaypointIndex++;
+        }
+        public override void StartRacer() => navMeshAgent.isStopped = false;
+        public override void StopRacer() => navMeshAgent.isStopped = true;
+        public override void NextWaypoint()
+        {
+            if(CurrentWaypointIndex >= Waypoints.Count) CurrentWaypointIndex = 0;
+            
+            navMeshAgent.destination = Waypoints[CurrentWaypointIndex++].position;
+        }
+    }
+}

Assets/Code/Example/Race/Racer/AI/AIRacer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 05f30660967e40209aa88719fa498c78
+timeCreated: 1769694590

Assets/Code/Example/Race/Racer/AI/PlayerRacer.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Code.Example.Race.Racer.AI
+{
+    public class PlayerRacer : Racer
+    {
+        public override void SetData(RacerData data)
+        {
+            Data = data;
+        }
+
+        public override void Initialize(List<Transform> waypoints)
+        {
+            
+        }
+
+        public override void NextWaypoint()
+        {
+            
+        }
+
+        public override void StartRacer()
+        {
+            
+        }
+
+        public override void StopRacer()
+        {
+        }
+    }
+}

Assets/Code/Example/Race/Racer/AI/PlayerRacer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6d3497d41c87415eab67cfc865262b79
+timeCreated: 1769619757

Assets/Code/Example/Race/Racer/AI/Racer.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Code.Example.Race.Racer.AI
+{
+    public abstract class Racer : MonoBehaviour
+    {
+        protected List<Transform> Waypoints;
+        protected int CurrentWaypointIndex;
+        public RacerData Data { get; protected set; }
+        public int Id { get; set; }
+        public abstract void SetData(RacerData data);
+        public abstract void Initialize(List<Transform> waypoints);
+        public abstract void NextWaypoint();
+        public abstract void StartRacer();
+        public abstract void StopRacer();
+
+        [SerializeField] protected Rigidbody carRigidbody;
+        public Rigidbody CarRigidbody => GetComponent<Rigidbody>();
+    }
+}

Assets/Code/Example/Race/Racer/AI/Racer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7f87ed38713d4b779df9e46c83b03fb7
+timeCreated: 1769619306

Assets/Code/Example/Race/Racer/Car.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2c5dfd92289c4aa38bb9a8bafc07d204
+timeCreated: 1769699718

Assets/Code/Example/Race/Racer/Car/CarWheelRotator.cs

@@ -0,0 +1,32 @@
+using UnityEngine;
+using UnityEngine.AI;
+
+namespace Code.Example.Race.Racer.Car
+{
+    public class CarWheelRotator : MonoBehaviour
+    {
+        [SerializeField] private NavMeshAgent agent;
+        [SerializeField] private Transform[] wheels;
+        [SerializeField] private bool rotateDebug;
+
+        private void Update()
+        {
+            Vector3 wheelRotation;
+            foreach (var wheel in wheels)
+            {
+                if (rotateDebug)
+                {
+                    UnityEngine.Debug.DrawRay(
+                        wheel.position,
+                        Vector3.Project(agent.velocity, agent.gameObject.transform.right), 
+                        Color.yellow, 900f);
+                    UnityEngine.Debug.Log(Vector3.Project(agent.velocity, agent.gameObject.transform.right).magnitude);
+                }
+
+                wheelRotation = wheel.localRotation.eulerAngles;
+                wheelRotation.y = Vector3.Project(agent.velocity, agent.gameObject.transform.right).magnitude * 10f;
+                wheel.localRotation = Quaternion.Euler(wheelRotation);
+            }
+        }
+    }
+}

Assets/Code/Example/Race/Racer/Car/CarWheelRotator.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3634956b4d55431b8772a8612e2e3a4d
+timeCreated: 1769699734

Assets/Code/Example/Race/Racer/Car/CarWheelRotatorPlayer.cs

@@ -0,0 +1,23 @@
+using DG.Tweening;
+using UnityEngine;
+
+namespace Code.Example.Race.Racer.Car
+{
+    public class CarWheelRotatorPlayer : MonoBehaviour
+    {
+        [SerializeField] private Transform[] wheels;
+        [SerializeField] private bool rotateDebug;
+
+        public void RotateWheels(float amount)
+        {
+            // UnityEngine.Debug.Log("Rotating Wheels: " + amount);
+            foreach (var wheel in wheels)
+            {
+                var wheelRotation = wheel.localRotation.eulerAngles;
+                wheelRotation.y = amount;
+                wheel.DOLocalRotate(wheelRotation, 1f);
+                // wheel.localRotation = Quaternion.Euler(wheelRotation);
+            }
+        }
+    }
+}

Assets/Code/Example/Race/Racer/Car/CarWheelRotatorPlayer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c90fde90552d48f592b955cbf1ec5c77
+timeCreated: 1769705011

Assets/Code/Example/Race/Racer/Player.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7d9a0a4882314e2f91bb356ea0f82538
+timeCreated: 1769705255

Assets/Code/Example/Race/Racer/Player/PlayerCarController.cs

@@ -0,0 +1,55 @@
+using Code.Example.Race.Racer.AI;
+using Code.Example.Race.Racer.Car;
+using UnityEngine;
+
+namespace Code.Example.Race.Racer.Player
+{
+    public class PlayerCarController : MonoBehaviour
+    {
+        [SerializeField] private Rigidbody _rigidbody;
+        [SerializeField] private PlayerCarInput _playerCarInput;
+        [SerializeField] private PlayerRacer _playerRacer;
+        [SerializeField] private CarWheelRotatorPlayer _wheels;
+
+        private void Update()
+        {
+            if (_playerCarInput.MovementInput == Vector2.zero) return;
+
+            // var movementForward = transform.forward * (_playerCarInput.MovementInput.y * _playerRacer.Data.speed);
+            //
+            // _rigidbody.AddForce(movementForward * Time.fixedDeltaTime, ForceMode.Force);
+            
+            var force = transform.forward * (_playerCarInput.MovementInput.y * _playerRacer.Data.speed);
+            _rigidbody.AddForce(force, ForceMode.Force);
+
+            // if (Mathf.Abs(_playerCarInput.MovementInput.y) < 0.1f && _rigidbody.linearVelocity.magnitude > 0.3f)
+            // {
+            //     _rigidbody.AddForce(-_rigidbody.linearVelocity * (_playerRacer.Data.brakeForce * Time.fixedDeltaTime),
+            //         ForceMode.Force);
+            // }
+
+            var steerInput = _playerCarInput.MovementInput.x;
+            if (_playerCarInput.MovementInput.y < 0)
+                steerInput = -_playerCarInput.MovementInput.x;
+
+            // var steer = steerInput * maxSteerAngle;
+            //
+            // if (frontLeftWheel) frontLeftWheel.localRotation = Quaternion.Euler(0, steer, 0);
+            // if (frontRightWheel) frontRightWheel.localRotation = Quaternion.Euler(0, steer, 0);
+
+            if (!(_rigidbody.linearVelocity.magnitude > 0.5f)) return;
+
+            // var turn = steerInput * _playerRacer.Data.turnSpeed * Time.fixedDeltaTime;
+            // _rigidbody.MoveRotation(_rigidbody.rotation * Quaternion.Euler(0, turn, 0));
+
+            if (!(_rigidbody.linearVelocity.magnitude is > 1f or < -1f)) return;
+
+            var rotateAmount = _playerCarInput.MovementInput.x * _playerRacer.Data.angularSpeed;
+
+            _wheels.RotateWheels(rotateAmount * 10 * Time.fixedDeltaTime);
+            var wheelRotation = transform.rotation.eulerAngles;
+            wheelRotation.y += rotateAmount;
+            transform.rotation = Quaternion.Euler(wheelRotation);
+        }
+    }
+}

Assets/Code/Example/Race/Racer/Player/PlayerCarController.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4b9e2e4a3ddc437ab250f609ea7fc33e
+timeCreated: 1769705285

Assets/Code/Example/Race/Racer/Player/PlayerCarControllerRB.cs

@@ -0,0 +1,166 @@
+using UnityEngine;
+using System;
+using System.Collections.Generic;
+
+namespace Code.Example.Race.Racer.Player
+{
+    public class PlayerCarControllerRB : MonoBehaviour
+    {
+        public enum ControlMode
+        {
+            Keyboard,
+            Buttons
+        };
+
+        public enum Axel
+        {
+            Front,
+            Rear
+        }
+
+        [Serializable]
+        public struct Wheel
+        {
+            public GameObject wheelModel;
+            public WheelCollider wheelCollider;
+            public GameObject wheelEffectObj;
+            public ParticleSystem smokeParticle;
+            public Axel axel;
+        }
+
+        public ControlMode control;
+
+        public float maxAcceleration = 30.0f;
+        public float brakeAcceleration = 50.0f;
+
+        public float turnSensitivity = 1.0f;
+        public float maxSteerAngle = 30.0f;
+
+        public Vector3 _centerOfMass;
+
+        public List<Wheel> wheels;
+
+        float moveInput;
+        float steerInput;
+
+        private Rigidbody carRb;
+
+        // private CarLights carLights;
+
+        void Start()
+        {
+            carRb = GetComponent<Rigidbody>();
+            carRb.centerOfMass = _centerOfMass;
+
+            carLights = GetComponent<CarLights>();
+        }
+
+        void Update()
+        {
+            GetInputs();
+            AnimateWheels();
+            WheelEffects();
+        }
+
+        void LateUpdate()
+        {
+            Move();
+            Steer();
+            Brake();
+        }
+
+        public void MoveInput(float input)
+        {
+            moveInput = input;
+        }
+
+        public void SteerInput(float input)
+        {
+            steerInput = input;
+        }
+
+        void GetInputs()
+        {
+            if (control == ControlMode.Keyboard)
+            {
+                moveInput = Input.GetAxis("Vertical");
+                steerInput = Input.GetAxis("Horizontal");
+            }
+        }
+
+        void Move()
+        {
+            foreach (var wheel in wheels)
+            {
+                wheel.wheelCollider.motorTorque = moveInput * 600 * maxAcceleration * Time.deltaTime;
+            }
+        }
+
+        void Steer()
+        {
+            foreach (var wheel in wheels)
+            {
+                if (wheel.axel == Axel.Front)
+                {
+                    var _steerAngle = steerInput * turnSensitivity * maxSteerAngle;
+                    wheel.wheelCollider.steerAngle = Mathf.Lerp(wheel.wheelCollider.steerAngle, _steerAngle, 0.6f);
+                }
+            }
+        }
+
+        void Brake()
+        {
+            if (Input.GetKey(KeyCode.Space) || moveInput == 0)
+            {
+                foreach (var wheel in wheels)
+                {
+                    wheel.wheelCollider.brakeTorque = 300 * brakeAcceleration * Time.deltaTime;
+                }
+
+                carLights.isBackLightOn = true;
+                carLights.OperateBackLights();
+            }
+            else
+            {
+                foreach (var wheel in wheels)
+                {
+                    wheel.wheelCollider.brakeTorque = 0;
+                }
+
+                carLights.isBackLightOn = false;
+                carLights.OperateBackLights();
+            }
+        }
+
+        void AnimateWheels()
+        {
+            foreach (var wheel in wheels)
+            {
+                Quaternion rot;
+                Vector3 pos;
+                wheel.wheelCollider.GetWorldPose(out pos, out rot);
+                wheel.wheelModel.transform.position = pos;
+                wheel.wheelModel.transform.rotation = rot;
+            }
+        }
+
+        void WheelEffects()
+        {
+            foreach (var wheel in wheels)
+            {
+                //var dirtParticleMainSettings = wheel.smokeParticle.main;
+
+                if (Input.GetKey(KeyCode.Space) && wheel.axel == Axel.Rear && wheel.wheelCollider.isGrounded == true &&
+                    carRb.linearVelocity.magnitude >= 10.0f)
+                {
+                    wheel.wheelEffectObj.GetComponentInChildren<TrailRenderer>().emitting = true;
+                    wheel.smokeParticle.Emit(1);
+                }
+                else
+                {
+                    wheel.wheelEffectObj.GetComponentInChildren<TrailRenderer>().emitting = false;
+                }
+            }
+        }
+    }
+}

Assets/Code/Example/Race/Racer/Player/PlayerCarControllerRB.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5f093c913ff54cb99cd22d7e473931e7
+timeCreated: 1770299509

Assets/Code/Example/Race/Racer/Player/PlayerCarInput.cs

@@ -0,0 +1,32 @@
+using Code.Infrastructure.Input;
+using Reflex.Attributes;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+namespace Code.Example.Race.Racer.Player
+{
+    public class PlayerCarInput : MonoBehaviour
+    {
+        private IInputService _inputService;
+        public Vector2 MovementInput { get; private set; }
+
+        [Inject]
+        public void Construct(IInputService inputService)
+        {
+            _inputService = inputService;
+            _inputService.BindActionPerformed((int)ActionMappings.Gameplay, (int)GameplayActions.Move, MovementPerformed);
+            _inputService.BindActionCancel((int)ActionMappings.Gameplay, (int)GameplayActions.Move, MovementEnded);
+        }
+
+        private void MovementPerformed(InputAction.CallbackContext context) => MovementInput = context.ReadValue<Vector2>();
+
+        private void MovementEnded(InputAction.CallbackContext context) => MovementInput = Vector2.zero;
+
+        private void OnDestroy()
+        {
+            if (_inputService == null) return;
+            _inputService.UnbindActionPerformed((int)ActionMappings.Gameplay, (int)GameplayActions.Move, MovementPerformed);
+            _inputService.UnbindActionCanceled((int)ActionMappings.Gameplay, (int)GameplayActions.Move, MovementEnded);
+        }
+    }
+}

Assets/Code/Example/Race/Racer/Player/PlayerCarInput.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e52315b65c57499981981e2507aaf7bc
+timeCreated: 1769705872

Assets/Code/Example/Race/Racer/RacerFactory.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Code.Infrastructure.Configs;
+using Code.Infrastructure.EventBus;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+using UnityEngine.ResourceManagement.AsyncOperations;
+using EventBus = Code.Infrastructure.EventBus.EventBus;
+
+namespace Code.Example.Race.Racer
+{
+    public interface IRacerFactory
+    {
+        RacerSettingsConfig GetConfig(RacerType racerType);
+        UniTaskVoid LoadRacer(RacerType racerType);
+        void ReleaseRacer(RacerType racerType);
+    }
+
+    public class RacerFactory : IDisposable, IRacerFactory
+    {
+        private Dictionary<RacerType, RacerSettingsConfig> _racerConfigs;
+        private Dictionary<RacerType, AsyncOperationHandle<GameObject>> _racerPrefabsHandle = new();
+
+        private string _racerConfigsLabel;
+        private AsyncOperationHandle<IList<RacerSettingsConfig>> _racerConfigsHandle;
+
+        private EventBus _eventBus;
+
+        public RacerFactory(IConfigLocator configLocator, EventBus eventBus)
+        {
+            _eventBus = eventBus;
+            _racerConfigsLabel = configLocator.TryGetManyConfigAssetReferences<RacerSettingsConfig>();
+
+            LoadConfigs().Forget();
+        }
+
+        private async UniTaskVoid LoadConfigs()
+        {
+            _racerConfigsHandle = Addressables.LoadAssetsAsync<RacerSettingsConfig>(_racerConfigsLabel);
+
+            await _racerConfigsHandle.ToUniTask();
+
+            _racerConfigs = _racerConfigsHandle.Result.ToDictionary(x => x.racerData.type);
+
+            _eventBus.RaiseEvent<IRacerFactoryInitializedHandle>(x => x.RacerFactoryInitialized());
+        }
+        
+        public RacerSettingsConfig GetConfig(RacerType racerType) => _racerConfigs[racerType];
+        
+        public async UniTaskVoid LoadRacer(RacerType racerType)
+        {
+            if (_racerPrefabsHandle.ContainsKey(racerType))
+            {
+                _eventBus.RaiseEvent<IRacerLoadedHandle>(x => x.RacerLoaded(racerType, null));
+
+                return;
+            }
+            
+            _racerPrefabsHandle.Add(racerType,
+                Addressables.LoadAssetAsync<GameObject>(_racerConfigs[racerType].prefabReference));
+            
+            await _racerPrefabsHandle[racerType].ToUniTask();
+            var racer = _racerPrefabsHandle[racerType].Result.GetComponent<AI.Racer>();
+            racer.SetData(_racerConfigs[racerType].racerData);
+            
+            _eventBus.RaiseEvent<IRacerLoadedHandle>(x => x.RacerLoaded(racerType, racer));
+        }
+
+        public void ReleaseRacer(RacerType racerType)
+        {
+            _racerPrefabsHandle[racerType].Release();
+            _racerPrefabsHandle.Remove(racerType);
+        }
+
+        public void Dispose()
+        {
+            foreach (var prefab in _racerPrefabsHandle) 
+                prefab.Value.Release();
+            
+            _racerConfigsHandle.Release();
+        }
+    }
+
+    public interface IRacerFactoryInitializedHandle : IGlobalSubscriber
+    {
+        public void RacerFactoryInitialized();
+    }
+
+    public interface IRacerLoadedHandle : IGlobalSubscriber
+    {
+        public void RacerLoaded(RacerType type, AI.Racer racer);
+        public void RacerCreated(RacerType type, AI.Racer racer);
+    }
+}

Assets/Code/Example/Race/Racer/RacerFactory.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5ab404f94a89460eae107b9d453fa64d
+timeCreated: 1769620039

Assets/Code/Example/Race/Racer/RacerSettings.cs

@@ -0,0 +1,27 @@
+using System;
+using Code.Infrastructure.Generators;
+using UnityEngine.AddressableAssets;
+
+namespace Code.Example.Race.Racer
+{
+    [Config("Configs/Gameplay/RacerSettings", true)]
+    public class RacerSettings
+    {
+        [ToConfig] public RacerData racerData;
+
+        [ToConfig] public AssetReference prefabReference;
+    }
+
+    [Serializable]
+    public struct RacerData
+    {
+        public string name;
+        public float speed;
+        public float angularSpeed;
+        public float maxAcceleration;
+        public float brakeAcceleration;
+        public float turnSensitivity;
+        public float maxSteerAngle;
+        public RacerType type;
+    }
+}

Assets/Code/Example/Race/Racer/RacerSettings.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f25b32b493144bfc9ca0c5016741d012
+timeCreated: 1769619229

Assets/Code/Example/Race/Racer/RacerType.cs

@@ -0,0 +1,9 @@
+namespace Code.Example.Race.Racer
+{
+    public enum RacerType
+    {
+        Player,
+        AIGreen,
+        AIRed
+    }
+}

Assets/Code/Example/Race/Racer/RacerType.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 488f864fcf6f4632b8d50b39038f5472
+timeCreated: 1769619126

Assets/Code/Example/Race/Racer/RacistSpawnListDebug.cs

@@ -0,0 +1,7 @@
+namespace Code.Example.Race.Racer
+{
+    public class RacistSpawnListDebug
+    {
+        
+    }
+}

Assets/Code/Example/Race/Racer/RacistSpawnListDebug.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a9506da417a249929493862133eef179
+timeCreated: 1769685790

Assets/Code/Example/Race/Track/CheckPoint.cs

@@ -1,14 +1,24 @@
 using Code.Example.Race.Racer.AI;
+using Code.Infrastructure.EventBus;
+using Reflex.Attributes;
 using UnityEngine;
 
 namespace Code.Example.Race.Track
 {
     public class CheckPoint : MonoBehaviour
     {
+        [Inject] private EventBus _eventBus;
         private void OnTriggerEnter(Collider other)
         {
-            var racer = other.GetComponent<AIDebugRacer>();
+            var racer = other.GetComponent<Racer.AI.Racer>();
             racer.NextWaypoint();
+            
+            _eventBus.RaiseEvent<IRacerPassedCheckpointHandler>(h => h.OnRacerPassedCheckpoint(racer));
         }
     }
+
+    public interface IRacerPassedCheckpointHandler : IGlobalSubscriber
+    {
+        void OnRacerPassedCheckpoint(Racer.AI.Racer racer);
+    }
 }

Assets/Code/Example/Race/Track/RaceTrackData.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Code.Example.Race.Track
+{
+    public class RaceTrackData : MonoBehaviour
+    {
+        public Transform CameraPosition;
+        public TrackData trackData;
+    }
+
+    [System.Serializable]
+    public struct TrackData
+    {
+        public List<Transform> RacerPoints;
+        public List<Transform> Checkpoints;
+    }
+}

Assets/Code/Example/Race/Track/RaceTrackData.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1847a22e722c47c48ec0ce7d5a929580
+timeCreated: 1769686034

Assets/Code/Example/Race/Track/WellEditor.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: af09293375544928a9b19a6b697f214e
+timeCreated: 1770036714

Assets/Code/Example/Race/Track/WellEditor/CheckPointAsset.cs

@@ -0,0 +1,39 @@
+namespace Code.Example.Race.Track.WellEditor
+{
+    using UnityEngine;
+    using UnityEditor;
+
+    public static class CheckPointAsset
+    {
+        [MenuItem("GameObject/Track/CheckPoint", false, 1)]
+        private static void CreateCustomPrefab()
+        {
+            // Define the path to your prefab in the Project (must be in an "Assets" relative path)
+            var prefabPath = "Assets/Resources/Example/Misc/Point.prefab"; // Update with your actual path
+
+            // Load the prefab asset
+            var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
+
+            if (!prefab)
+            {
+                Debug.LogError("Prefab not found at path: " + prefabPath);
+                return;
+            }
+
+            // Instantiate the prefab in the scene
+            var newInstance = (GameObject)PrefabUtility.InstantiatePrefab(prefab);
+        
+            // Ensure it is placed correctly in the Hierarchy and is undoable
+            Undo.RegisterCreatedObjectUndo(newInstance, "Create Custom Prefab");
+            Selection.activeGameObject = newInstance;
+
+            // Set parent if an object is selected
+            if (!Selection.activeTransform)
+            {
+                newInstance.transform.parent = Selection.activeTransform;
+                newInstance.transform.localPosition = Vector3.zero;
+            }
+        }
+    }
+
+}

Assets/Code/Example/Race/Track/WellEditor/CheckPointAsset.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7d55e4bcf05848eea361440799c21d7e
+timeCreated: 1770036738

Assets/Code/Example/Race/UI.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b875d3daf0cc42e997366fb0b9f0a722
+timeCreated: 1770042347

Assets/Code/Example/Race/UI/PlayerScoreCounter.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using Code.Example.Race.Racer;
+using Code.Example.Race.Track;
+using Code.Infrastructure.EventBus;
+using Code.Infrastructure.UI;
+using Reflex.Attributes;
+using TMPro;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace Code.Example.Race.UI
+{
+    public class PlayerScoreCounter : UIPanel, IScoreChangedHandle
+    {
+        [SerializeField] private TMP_Text playerScore;
+        private EventBus _eventBus;
+
+        [Inject]
+        private void Construct(EventBus eventBus)
+        {
+            _eventBus = eventBus;
+            _eventBus.Subscribe(this);
+        }
+        public override void Open(Action callback = null)
+        {
+            playerScore.gameObject.SetActive(true);
+            // image.DOColor(shownColor, 1f).onComplete = () => callback?.Invoke(); 
+        }
+
+        public override void Close(Action callback = null)
+        {
+            playerScore.gameObject.SetActive(true);
+            // image.DOColor(hiddenColor, 1f).onComplete += () => callback?.Invoke(); 
+        }
+
+        public void OnRacerPassedCheckpoint(Racer.AI.Racer racer)
+        {
+        }
+
+        public void ScoreChanged(int racer, int additionalScore, List<KeyValuePair<int,int>> scores)
+        {
+            // if (racer.Data.type == RacerType.Player)
+            string output = "";
+            foreach (var score in scores) output += $@"{score.Key}: {score.Value}\n";
+            playerScore.text = output;
+        }
+    }
+}

Assets/Code/Example/Race/UI/PlayerScoreCounter.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cf68a9a9d3a946f086dccd6d11741dcf
+timeCreated: 1770042362