Victor Rosas

using Unity.Burst;
using Unity.Collections;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;

public class ProjectileSimulator : MonoBehaviour
{
    [SerializeField] private float gravity        = -18f;
    [SerializeField] private float drag           = 0.015f;
    [SerializeField] private int   maxProjectiles = 512;

    private NativeArray<float3> _positions;
    private NativeArray<float3> _velocities;
    private NativeArray<float>  _lifetimes;
    private NativeArray<bool>   _alive;
    private int                 _count;
    private JobHandle           _handle;

    [BurstCompile]
    struct SimulateJob : IJobParallelFor
    {
        public float               DeltaTime;
        public float               Gravity;
        public float               Drag;
        public NativeArray<float3> Positions;
        public NativeArray<float3> Velocities;
        public NativeArray<float>  Lifetimes;
        public NativeArray<bool>   Alive;

        public void Execute(int i)
        {
            if (!Alive[i]) return;

            Lifetimes[i] -= DeltaTime;
            if (Lifetimes[i] <= 0f) { Alive[i] = false; return; }

            float3 vel = Velocities[i];
            vel.y     += Gravity * DeltaTime;
            vel        = vel * (1f - Drag * DeltaTime);

            Positions[i]  += vel * DeltaTime;
            Velocities[i]  = vel;
        }
    }

    private void Awake()
    {
        _positions  = new NativeArray<float3>(maxProjectiles, Allocator.Persistent);
        _velocities = new NativeArray<float3>(maxProjectiles, Allocator.Persistent);
        _lifetimes  = new NativeArray<float>(maxProjectiles,  Allocator.Persistent);
        _alive      = new NativeArray<bool>(maxProjectiles,   Allocator.Persistent);
    }

    private void Update()
    {
        _handle.Complete();

        // collision + cleanup on main thread (can't do Physics calls inside jobs)
        for (int i = 0; i < _count; )
        {
            if (!_alive[i] || Physics.CheckSphere(
                    (Vector3)_positions[i], 0.12f,
                    LayerMask.GetMask("Enemy", "World")))
            {
                OnDied((Vector3)_positions[i]);

                // swap-remove: pull last element into this slot
                _count--;
                _positions[i]  = _positions[_count];
                _velocities[i] = _velocities[_count];
                _lifetimes[i]  = _lifetimes[_count];
                _alive[i]      = _alive[_count];
            }
            else i++;
        }

        _handle = new SimulateJob
        {
            DeltaTime  = Time.deltaTime,
            Gravity    = gravity,
            Drag       = drag,
            Positions  = _positions,
            Velocities = _velocities,
            Lifetimes  = _lifetimes,
            Alive      = _alive,
        }.Schedule(_count, 64);
    }

    public void Spawn(Vector3 pos, Vector3 vel, float life)
    {
        if (_count >= maxProjectiles) return;

        _handle.Complete();   // can't write to NativeArrays while job is running
        _positions[_count]  = pos;
        _velocities[_count] = vel;
        _lifetimes[_count]  = life;
        _alive[_count]      = true;
        _count++;
    }

    private void OnDied(Vector3 pos) { /* trigger pooled VFX here */ }

    private void OnDestroy()
    {
        _handle.Complete();
        _positions.Dispose();
        _velocities.Dispose();
        _lifetimes.Dispose();
        _alive.Dispose();
    }
}

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.XR;

[RequireComponent(typeof(Rigidbody))]
public class VRPhysicsHand : MonoBehaviour
{
    [SerializeField] private Transform target;
    [SerializeField] private float     posStrength     = 30f;
    [SerializeField] private float     rotStrength     = 20f;
    [SerializeField] private float     hapticThreshold = 2.5f;
    [SerializeField] private XRNode    hand            = XRNode.RightHand;

    private Rigidbody               _rb;
    private InputDevice             _device;
    private readonly Queue<Vector3> _linHistory = new();
    private readonly Queue<Vector3> _angHistory = new();
    private const int               HistorySize = 8;

    private void Awake() => _rb = GetComponent<Rigidbody>();

    private void OnEnable()
    {
        InputDevices.deviceConnected    += OnConnected;
        InputDevices.deviceDisconnected += OnDisconnected;
        TryAcquireDevice();
    }

    private void OnDisable()
    {
        InputDevices.deviceConnected    -= OnConnected;
        InputDevices.deviceDisconnected -= OnDisconnected;
    }

    private void FixedUpdate()
    {
        // position: drive velocity toward target each physics step
        Vector3 delta    = target.position - transform.position;
        _rb.velocity     = delta * posStrength;

        // rotation: convert delta quaternion to angular velocity
        Quaternion dRot  = target.rotation * Quaternion.Inverse(transform.rotation);
        dRot.ToAngleAxis(out float angle, out Vector3 axis);
        if (!float.IsInfinity(axis.x))
            _rb.angularVelocity = axis * (angle * Mathf.Deg2Rad * rotStrength);

        Enqueue(_linHistory, _rb.velocity);
        Enqueue(_angHistory, _rb.angularVelocity);
    }

    private static void Enqueue(Queue<Vector3> q, Vector3 v)
    {
        q.Enqueue(v);
        if (q.Count > HistorySize) q.Dequeue();
    }

    // call these from the grab/release handler instead of reading rb.velocity directly
    public Vector3 GetThrowVelocity() => Average(_linHistory);
    public Vector3 GetThrowAngular()  => Average(_angHistory);

    private static Vector3 Average(Queue<Vector3> q)
    {
        if (q.Count == 0) return Vector3.zero;
        Vector3 sum = Vector3.zero;
        foreach (var v in q) sum += v;
        return sum / q.Count;
    }

    private void OnCollisionEnter(Collision col)
    {
        float impulse = col.impulse.magnitude;
        if (impulse < hapticThreshold || !_device.isValid) return;

        float strength = Mathf.Clamp01(impulse / 12f);
        float duration = Mathf.Lerp(0.05f, 0.3f, strength);
        _device.SendHapticImpulse(0, strength, duration);
    }

    private void TryAcquireDevice()
    {
        var devices = new List<InputDevice>();
        var flags   = InputDeviceCharacteristics.Controller |
                      (hand == XRNode.RightHand
                          ? InputDeviceCharacteristics.Right
                          : InputDeviceCharacteristics.Left);
        InputDevices.GetDevicesWithCharacteristics(flags, devices);
        if (devices.Count > 0) _device = devices[0];
    }

    private void OnConnected(InputDevice d)
    {
        if (d.characteristics.HasFlag(InputDeviceCharacteristics.Controller))
            TryAcquireDevice();
    }

    private void OnDisconnected(InputDevice d)
    {
        if (_device == d) _device = default;
    }
}

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using UnityEngine;

public sealed class SaveSystem
{
    private static readonly Lazy<SaveSystem> _lazy =
        new Lazy<SaveSystem>(() => new SaveSystem());

    public static SaveSystem Instance => _lazy.Value;

    private readonly SemaphoreSlim       _lock = new SemaphoreSlim(1, 1);
    private          CancellationTokenSource _cts;

    private SaveSystem() { }

    public async Task SaveAsync<T>(string slot, T data) where T : class
    {
        // cancel any in-flight save for this slot — last write wins
        _cts?.Cancel();
        _cts?.Dispose();
        _cts = new CancellationTokenSource();
        var token = _cts.Token;

        await _lock.WaitAsync(token);
        try
        {
            token.ThrowIfCancellationRequested();
            string json = JsonUtility.ToJson(data, prettyPrint: false);
            await WriteAtomicAsync(SlotPath(slot), json, token);
        }
        catch (OperationCanceledException)
        {
            Debug.Log($"[SaveSystem] '{slot}' write superseded by a newer save.");
        }
        finally
        {
            _lock.Release();
        }
    }

    public async Task<T> LoadAsync<T>(string slot) where T : class, new()
    {
        string path = SlotPath(slot);
        if (!File.Exists(path)) return new T();

        await _lock.WaitAsync();
        try
        {
            string raw = await Task.Run(() => File.ReadAllText(path));
            return JsonUtility.FromJson<T>(raw) ?? new T();
        }
        finally
        {
            _lock.Release();
        }
    }

    private static async Task WriteAtomicAsync(
        string path, string json, CancellationToken ct)
    {
        string tmp = path + ".tmp";
        await Task.Run(() => File.WriteAllText(tmp, json), ct);
        ct.ThrowIfCancellationRequested();
        File.Move(tmp, path, overwrite: true);   // atomic on same filesystem
    }

    private static string SlotPath(string slot) =>
        Path.Combine(Application.persistentDataPath, slot + ".json");
}