// Unity Netcode 状态同步示例
public class PlayerHealth : NetworkBehaviour
{
    private NetworkVariable<int> health = new NetworkVariable<int>(
        100,
        NetworkVariableReadPermission.Everyone,
        NetworkVariableWritePermission.Server
    );

    public void TakeDamage(int damage)
    {
        if (!IsServer) return;
        health.Value = Mathf.Max(0, health.Value - damage);
    }

    public override void OnNetworkSpawn()
    {
        health.OnValueChanged += (oldVal, newVal) =>
        {
            // 客户端自动收到回调，更新 UI
            UpdateHealthUI(newVal);
        };
    }
}

// 帧同步核心逻辑伪代码
public class LockstepManager
{
    private int currentTick = 0;
    private Dictionary<int, PlayerInput[]> inputBuffer = new();

    public void OnReceiveInput(int playerId, int tick, PlayerInput input)
    {
        if (!inputBuffer.ContainsKey(tick))
            inputBuffer[tick] = new PlayerInput[playerCount];

        inputBuffer[tick][playerId] = input;

        // 检查当前帧所有玩家输入是否到齐
        if (inputBuffer[currentTick] != null &&
            inputBuffer[currentTick].All(i => i != null))
        {
            SimulateTick(currentTick, inputBuffer[currentTick]);
            currentTick++;
        }
    }

    private void SimulateTick(int tick, PlayerInput[] inputs)
    {
        // 所有客户端用相同输入执行相同逻辑
        // 必须使用定点数！
        for (int i = 0; i < inputs.Length; i++)
        {
            players[i].ApplyInput(inputs[i]);
        }
        gameState.Simulate();
    }
}

public class ClientPrediction
{
    private List<InputCommand> pendingInputs = new();
    private PlayerState predictedState;

    // 客户端本地执行
    public void ProcessInput(InputCommand input)
    {
        // 1. 立即在本地应用（预测）
        predictedState = ApplyInput(predictedState, input);
        pendingInputs.Add(input);

        // 2. 发送给服务器
        SendToServer(input);
    }

    // 服务器确认返回
    public void OnServerAck(int lastProcessedSeq, PlayerState serverState)
    {
        // 1. 移除服务器已处理的输入
        pendingInputs.RemoveAll(i => i.Sequence <= lastProcessedSeq);

        // 2. 从服务器状态重新应用未确认的输入
        predictedState = serverState;
        foreach (var input in pendingInputs)
        {
            predictedState = ApplyInput(predictedState, input);
        }
    }
}

public class ServerReconciliation
{
    public PlayerState ProcessInput(int playerId, InputCommand input)
    {
        // 服务器执行权威模拟
        var player = players[playerId];
        var newState = ApplyInput(player.State, input);

        // 合法性检查
        if (!ValidateMove(player.State, newState))
        {
            // 拒绝非法移动（可能是作弊）
            return player.State;
        }

        player.State = newState;
        player.LastProcessedSeq = input.Sequence;

        return newState;
    }

    private bool ValidateMove(PlayerState old, PlayerState @new)
    {
        float maxSpeed = 10f;
        float distance = Vector3.Distance(old.Position, @new.Position);
        float time = @new.Timestamp - old.Timestamp;
        return distance / time <= maxSpeed * 1.1f; // 10% 容差
    }
}

public class EntityInterpolation : MonoBehaviour
{
    private struct StateSnapshot
    {
        public float Timestamp;
        public Vector3 Position;
        public Quaternion Rotation;
    }

    private List<StateSnapshot> snapshots = new();
    private float interpolationDelay = 0.1f; // 100ms 缓冲

    public void AddSnapshot(Vector3 pos, Quaternion rot, float time)
    {
        snapshots.Add(new StateSnapshot
        {
            Timestamp = time,
            Position = pos,
            Rotation = rot
        });

        // 只保留最近 1 秒的快照
        snapshots.RemoveAll(s => s.Timestamp < Time.time - 1f);
    }

    void Update()
    {
        if (snapshots.Count < 2) return;

        // 渲染时间 = 当前时间 - 插值延迟
        float renderTime = Time.time - interpolationDelay;

        // 找到 renderTime 两侧的两个快照
        StateSnapshot from = default, to = default;
        for (int i = 0; i < snapshots.Count - 1; i++)
        {
            if (snapshots[i].Timestamp <= renderTime &&
                snapshots[i + 1].Timestamp >= renderTime)
            {
                from = snapshots[i];
                to = snapshots[i + 1];
                break;
            }
        }

        if (from.Timestamp == 0) return;

        float t = (renderTime - from.Timestamp) / (to.Timestamp - from.Timestamp);
        transform.position = Vector3.Lerp(from.Position, to.Position, t);
        transform.rotation = Quaternion.Slerp(from.Rotation, to.Rotation, t);
    }
}

public class EntityExtrapolation : MonoBehaviour
{
    private Vector3 lastPosition;
    private Vector3 lastVelocity;
    private float lastUpdateTime;

    public void UpdateFromServer(Vector3 position, Vector3 velocity, float time)
    {
        lastPosition = position;
        lastVelocity = velocity;
        lastUpdateTime = time;
    }

    void Update()
    {
        float elapsed = Time.time - lastUpdateTime;
        // 线性外推：位置 = 上次位置 + 速度 × 经过时间
        transform.position = lastPosition + lastVelocity * elapsed;
    }
}

public class LagCompensation
{
    private List<WorldSnapshot> history = new();

    // 服务器每 tick 记录历史
    public void RecordSnapshot()
    {
        history.Add(new WorldSnapshot
        {
            Timestamp = Time.time,
            PlayerPositions = GetAllPlayerPositions()
        });

        // 只保留最近 1 秒
        history.RemoveAll(s => s.Timestamp < Time.time - 1f);
    }

    // 处理射击命中判定
    public bool CheckHit(int shooterId, Ray shotRay, float clientTime)
    {
        // 找到客户端开枪时刻的世界状态
        var snapshot = history.OrderBy(s =>
            Mathf.Abs(s.Timestamp - clientTime)).First();

        // 用过去的玩家位置做命中检测
        foreach (var kvp in snapshot.PlayerPositions)
        {
            if (kvp.Key == shooterId) continue;
            if (HitboxCheck(kvp.Value, shotRay))
                return true;
        }
        return false;
    }
}

public class DeltaCompression
{
    private Dictionary<string, object> lastSentState = new();

    public byte[] CompressState(Dictionary<string, object> currentState)
    {
        var delta = new Dictionary<string, object>();

        foreach (var kvp in currentState)
        {
            if (!lastSentState.ContainsKey(kvp.Key) ||
                !lastSentState[kvp.Key].Equals(kvp.Value))
            {
                delta[kvp.Key] = kvp.Value;
            }
        }

        lastSentState = new Dictionary<string, object>(currentState);
        return Serialize(delta);
    }
}

# Unity Package Manager 安装
# 添加 com.unity.netcode.gameobjects
# 添加 com.unity.transport（底层传输）

// 启动主机（同时作为服务器和客户端）
NetworkManager.Singleton.StartHost();

// 启动专用客户端
NetworkManager.Singleton.StartClient();

// 启动专用服务器
NetworkManager.Singleton.StartServer();

// 生成网络对象
var playerObj = NetworkManager.Singleton.SpawnManager
    .GetPlayerPrefab(connectionId);
playerObj.SpawnAsPlayerObject(connectionId);

extends CharacterBody3D

# 标记为 RPC 方法
@rpc("any_peer", "call_local")
func shoot(direction: Vector3):
    # 所有客户端都会执行
    spawn_bullet(direction)

@rpc("authority", "call_local")
func take_damage(amount: int):
    health -= amount
    if health <= 0:
        die()

# 同步变量
@export var health: int = 100:
    set(value):
        health = value
        health_changed.emit(health)

# MultiplayerSynchronizer 自动同步属性
# 添加到场景树，配置要同步的属性即可
var synchronizer = MultiplayerSynchronizer.new()
synchronizer.replication_interval = 1.0 / 20.0  # 20 Hz
add_child(synchronizer)

# 基于 AWS Auto Scaling 的配置示例
scaling_policy:
  target_tracking:
    target_value: 70  # CPU 利用率目标 70%
    scale_in_cooldown: 300  # 缩容冷却 5 分钟
    scale_out_cooldown: 60  # 扩容冷却 1 分钟
  min_capacity: 2
  max_capacity: 50
  scheduled_actions:
    - name: "evening_peak"
      cron: "0 18 * * *"  # 每天 18:00
      min_capacity: 10
    - name: "late_night"
      cron: "0 2 * * *"   # 每天 02:00
      min_capacity: 2