Project-M/Assets/_Project/Scripts/Authoring/Player/PlayerAuthoring.cs

using ProjectM.Simulation;
using Unity.Entities;
using UnityEngine;

namespace ProjectM.Authoring
{
    /// <summary>
    /// Authoring for the player ghost prefab. As of M3 the numeric tunables live in data
    /// (<see cref="CharacterStatsDefinition"/> / <see cref="AbilityDefinition"/> ScriptableObjects);
    /// this authoring only selects which definitions the player uses and bakes the light id refs, the
    /// (empty) replicated modifier buffer, and the zeroed effective-stat components that
    /// StatRecomputeSystem fills each predicted tick. Health is seeded from the character definition's
    /// MaxHealth (single source). Ghost replication, <c>GhostOwner</c> and AutoCommandTarget come from
    /// the GhostAuthoringComponent on the same prefab GameObject; <c>GetEntity(TransformUsageFlags.Dynamic)</c>
    /// ensures a runtime-mutable LocalTransform exists.
    /// </summary>
    public class PlayerAuthoring : MonoBehaviour
    {
        [Tooltip("Character-stats definition (move speed, turn rate, max health). Single source of those values.")]
        public CharacterStatsDefinition Character;

        [Tooltip("Ability definition occupying the player's primary slot.")]
        public AbilityDefinition PrimaryAbility;

        [Header("Fallbacks (used only if a definition above is unassigned)")]
        [Min(0f)] public float FallbackMaxHealth = 100f;

        /// <summary>Projectile hit-test radius for the player as a damageable target, in world units.</summary>
        [Min(0f)] public float HitRadius = 0.6f;

        [Min(1)]
        [Tooltip("Ticks the player stays down before respawning at base (~60 ticks/sec).")]
        public int RespawnDelayTicks = 180;

        [Min(0)]
        [Tooltip("Ticks of post-respawn damage immunity (~60 ticks/sec).")]
        public int RespawnInvulnTicks = 120;

        private class PlayerBaker : Baker<PlayerAuthoring>
        {
            public override void Bake(PlayerAuthoring authoring)
            {
                var entity = GetEntity(authoring, TransformUsageFlags.Dynamic);

                // Re-bake when a referenced definition's serialized values change.
                if (authoring.Character != null) DependsOn(authoring.Character);
                if (authoring.PrimaryAbility != null) DependsOn(authoring.PrimaryAbility);

                byte characterId = authoring.Character != null
                    ? (byte)authoring.Character.Id : (byte)CharacterId.Default;
                byte abilityId = authoring.PrimaryAbility != null
                    ? (byte)authoring.PrimaryAbility.Id : (byte)AbilityId.Primary;
                float maxHealth = authoring.Character != null
                    ? authoring.Character.MaxHealth : authoring.FallbackMaxHealth;

                AddComponent<PlayerTag>(entity);
                AddComponent<PlayerFacing>(entity);
                AddComponent<PlayerInput>(entity);

                // Data-driven stat refs (replace M2's inlined PlayerMoveStats / AbilityStats values).
                AddComponent(entity, new CharacterStatsRef { Id = characterId });
                AddComponent(entity, new AbilityRef { Id = abilityId });
                // Unarmed/base ability restored on weapon-unequip (AbilityRef.Id mutates when a weapon is equipped).
                AddComponent(entity, new DefaultAbility { Id = abilityId });

                // Effective stats: zeroed at bake, recomputed every predicted tick by StatRecomputeSystem.
                AddComponent(entity, new EffectiveAbilityStats());
                AddComponent(entity, new EffectiveCharacterStats());

                // Empty replicated modifier stack (grown by upgrades/pickups/debug hook, server-authoritative).
                AddBuffer<StatModifier>(entity);
                // Empty replicated personal inventory (server-authoritative; harvest yield + deposit RPC land here).
                AddBuffer<InventorySlot>(entity);
                // Equipment loadout: one replicated row per slot in FIXED order (buffer index = EquipSlotId), empty.
                var equip = AddBuffer<EquipmentSlot>(entity);
                for (int s = 0; s < EquipSlotId.Count; s++)
                    equip.Add(new EquipmentSlot { ItemId = 0 });
                // Server-only expiry tracker for timed buffs (paired with a StatModifier by SourceId; not replicated).
                AddBuffer<TimedModifier>(entity);

                // Combat: server-authoritative health (Current replicated for display), the player's
                // damageable hit radius, predicted cooldown state, and the per-tick damage inbox.
                AddComponent(entity, new Health { Current = maxHealth, Max = maxHealth });
                AddComponent(entity, new HitRadius { Value = authoring.HitRadius });
                AddComponent<AbilityCooldown>(entity);
                AddBuffer<DamageEvent>(entity);
                // MC-1 dash: predicted dash window (derived from PlayerInput.Dash) + cooldown gate, baked idle/ready.
                AddComponent<DashState>(entity);
                AddComponent(entity, new DashCooldown { NextTick = 0 });
                // MC-4 melee combo: predicted, owner-replicated combo anchor (Step/SwingStartTick/LockUntilTick), baked idle/zero.
                AddComponent<MeleeCombo>(entity);

                // Death gate (enableable, derived from Health by PlayerDeathStateSystem) baked DISABLED = alive;
                // plus the server-only respawn timer.
                AddComponent<Dead>(entity);
                SetComponentEnabled<Dead>(entity, false);
                // Dev god-mode gate (enableable, server-only) baked DISABLED so toggling it is a bit flip, never structural.
                AddComponent<DebugGodMode>(entity);
                SetComponentEnabled<DebugGodMode>(entity, false);

                AddComponent(entity, new RespawnState { RespawnTick = 0, DelayTicks = authoring.RespawnDelayTicks, InvulnTicks = authoring.RespawnInvulnTicks });
                AddComponent(entity, new RespawnInvuln { UntilTick = 0 });

                // Expedition redesign (the ONE player-ghost re-bake, front-loaded): the send-to-all ready-check
                // flag + the owner-only choice-of-3 boon offer (inert until Step 9's BoonOfferSystem lights it up).
                AddComponent<PlayerReady>(entity);
                AddComponent<BoonOffer>(entity);
                // Phase 1.7 boon overhaul: the mechanic-changer state (replicated SendToOwner, baked inert, zeroed on
                // the Returning edge) + the server-only Blade-Dash per-dash dedup accumulator (non-replicated).
                AddComponent<BoonEffects>(entity);
                AddComponent<DashTrailState>(entity);
                // LANTERN Phase 1 (Step 1): 4-socket kit data model - parallels AbilityRef/AbilityCooldown
                // (both kept until the AbilityFireSystem migration in Step 2). AbilitySocket = cold per-socket
                // loadout (EquipmentSlot-modelled, 4 empty rows); SocketCooldown = hot owner-predicted per-socket
                // cooldown; FrameId = replicated frame/class signal (baked 0, written server-side at frame select).
                var sockets = AddBuffer<AbilitySocket>(entity);
                for (int sk = 0; sk < SocketId.Count; sk++)
                    sockets.Add(new AbilitySocket { SparkId = 0 });
                AddComponent<SocketCooldown>(entity);
                AddComponent<FrameId>(entity);
                // Step 1b: per-socket effective-stats buffer (4 rows), folded each predicted tick by
                // StatRecomputeSystem (additive; the legacy single EffectiveAbilityStats stays until steps 2/2.5).
                var effSockets = AddBuffer<EffectiveSocketStats>(entity);
                for (int sk2 = 0; sk2 < SocketId.Count; sk2++)
                    effSockets.Add(new EffectiveSocketStats());

            }
        }
    }
}