// 输入数据结构
[System.Serializable]
public struct FrameInput
{
    public int playerId;
    public int frame;
    public Vector2 moveDir;
    public bool firePressed;
}

// 帧同步管理器
public class LockstepManager : MonoBehaviour
{
    public static int CurrentFrame { get; private set; }
    private const float FrameInterval = 0.066f; // ~15帧/秒逻辑帧
    private float _timer;

    // 存储每帧所有玩家的输入
    private Dictionary<int, List<FrameInput>> _frameInputBuffer = new();

    // 本地玩家输入
    private FrameInput _localInput;

    void Update()
    {
        CollectLocalInput();

        _timer += Time.deltaTime;
        if (_timer >= FrameInterval)
        {
            _timer -= FrameInterval;
            TrySendInput();
        }
    }

    void CollectLocalInput()
    {
        _localInput = new FrameInput
        {
            playerId = NetworkManager.LocalPlayerId,
            frame = CurrentFrame,
            moveDir = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical")),
            firePressed = Input.GetButton("Fire1")
        };
    }

    void TrySendInput()
    {
        // 发送本地输入到服务器
        NetworkManager.Send(_localInput);
    }

    // 服务器广播回来后调用
    public void OnReceiveFrameInputs(List<FrameInput> inputs)
    {
        _frameInputBuffer[CurrentFrame] = inputs;
        ExecuteFrame(CurrentFrame, inputs);
        CurrentFrame++;
    }

    void ExecuteFrame(int frame, List<FrameInput> inputs)
    {
        foreach (var input in inputs)
        {
            var player = PlayerManager.GetPlayer(input.playerId);
            player.ApplyInput(input); // 确定性逻辑，不用 Time.deltaTime
        }

        // checksum 校验
        int checksum = ComputeChecksum();
        NetworkManager.SendChecksum(frame, checksum);
    }

    int ComputeChecksum()
    {
        // 简单示例：对所有玩家位置做哈希
        int hash = 0;
        foreach (var player in PlayerManager.AllPlayers)
        {
            hash ^= player.LogicPosition.GetHashCode();
        }
        return hash;
    }
}

// 玩家逻辑（必须确定性，避免浮点误差用定点数）
public class PlayerLogic : MonoBehaviour
{
    public Vector2Int LogicPosition; // 用整数或定点数
    private const int Speed = 5;

    public void ApplyInput(FrameInput input)
    {
        // 确定性移动，不依赖 Time.deltaTime
        LogicPosition += Vector2Int.RoundToInt(input.moveDir * Speed);
        transform.position = new Vector3(LogicPosition.x * 0.01f, 0, LogicPosition.y * 0.01f);
    }
}

// 状态数据结构
[System.Serializable]
public struct PlayerState
{
    public int playerId;
    public Vector3 position;
    public Vector3 velocity;
    public float timestamp;
}

// 服务器端逻辑（Server-side，可用 Mirror/Netcode 等框架）
public class ServerPlayerController : MonoBehaviour
{
    private Rigidbody _rb;
    private float _broadcastInterval = 0.05f; // 20次/秒
    private float _timer;

    void FixedUpdate()
    {
        _timer += Time.fixedDeltaTime;
        if (_timer >= _broadcastInterval)
        {
            _timer = 0;
            BroadcastState();
        }
    }

    // 收到客户端输入
    public void OnReceiveInput(Vector2 moveDir, int playerId)
    {
        // 服务器执行权威逻辑
        Vector3 force = new Vector3(moveDir.x, 0, moveDir.y) * 10f;
        _rb.AddForce(force);
    }

    void BroadcastState()
    {
        var state = new PlayerState
        {
            playerId = GetPlayerId(),
            position = transform.position,
            velocity = _rb.velocity,
            timestamp = Time.time
        };
        NetworkManager.BroadcastToAll(state);
    }
}

// 客户端插值
public class ClientPlayerInterpolation : MonoBehaviour
{
    private PlayerState _from;
    private PlayerState _to;
    private float _lerpT;
    private const float InterpDelay = 0.1f; // 100ms 缓冲

    private Queue<PlayerState> _stateBuffer = new();

    // 收到服务器状态
    public void OnReceiveState(PlayerState state)
    {
        _stateBuffer.Enqueue(state);
    }

    void Update()
    {
        float renderTime = Time.time - InterpDelay;

        // 找到合适的插值区间
        while (_stateBuffer.Count > 1 && _stateBuffer.Peek().timestamp <= renderTime)
        {
            _from = _stateBuffer.Dequeue();
        }

        if (_stateBuffer.Count > 0)
        {
            _to = _stateBuffer.Peek();
            float t = Mathf.InverseLerp(_from.timestamp, _to.timestamp, renderTime);
            transform.position = Vector3.Lerp(_from.position, _to.position, t);
        }
    }
}

// 客户端预测（本地玩家）
public class ClientPrediction : MonoBehaviour
{
    private Vector3 _predictedPos;
    private Rigidbody _rb;

    void Update()
    {
        // 本地立即响应输入
        Vector2 input = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"));
        _rb.AddForce(new Vector3(input.x, 0, input.y) * 10f);

        // 发送输入到服务器
        NetworkManager.SendInput(input);
    }

    // 服务器校正
    public void OnServerCorrection(PlayerState authoritative)
    {
        float posError = Vector3.Distance(transform.position, authoritative.position);
        if (posError > 0.5f)
        {
            // 误差过大，强制修正
            transform.position = authoritative.position;
            _rb.velocity = authoritative.velocity;
        }
        else
        {
            // 平滑修正
            transform.position = Vector3.Lerp(transform.position, authoritative.position, 0.3f);
        }
    }
}

float a = 1.0f / 3.0f;

// x86 FPU (80位精度中间计算): 0.33333334326744...
// ARM NEON (32位严格计算):     0.33333331346511...
// 结果不同！

// 累积误差示例：同样的逻辑跑1000帧
float pos = 0f;
for (int i = 0; i < 1000; i++)
    pos += 0.1f; // 每帧微小误差累积

// 平台A结果: 99.99999...
// 平台B结果: 100.00001...
// 1000帧后两个客户端玩家位置已经不同了

Fixed pos = Fixed.From(0);
Fixed step = Fixed.From(0.1f); // 初始化时转换一次

for (int i = 0; i < 1000; i++)
    pos += step; // 整数加法，任何平台结果都是同一个整数

// 所有平台：raw = 6553600，ToFloat() = 100.0 ✓

using Unity.Netcode;
using UnityEngine;

public class PlayerStats : NetworkBehaviour
{
    // 服务器修改，自动同步到所有客户端
    public NetworkVariable<int> Health = new(100);
    public NetworkVariable<Vector3> Position = new(Vector3.zero);

    public override void OnNetworkSpawn()
    {
        // 监听变化
        Health.OnValueChanged += OnHealthChanged;
    }

    void OnHealthChanged(int oldVal, int newVal)
    {
        // 客户端收到变化后更新 UI
        UIManager.UpdateHealthBar(newVal);
        if (newVal <= 0) PlayDeathEffect();
    }

    // 只有服务器能修改
    public void TakeDamage(int damage)
    {
        if (!IsServer) return;
        Health.Value = Mathf.Max(0, Health.Value - damage);
    }
}

public class InterpolatedTransform : NetworkBehaviour
{
    private struct TransformSnapshot
    {
        public float time;
        public Vector3 position;
        public Quaternion rotation;
    }

    private Queue<TransformSnapshot> _buffer = new();
    private const float BufferDelay = 0.1f; // 100ms 缓冲

    // 服务器广播位置
    [ClientRpc]
    public void UpdateTransformClientRpc(Vector3 pos, Quaternion rot)
    {
        if (IsOwner) return; // 本地玩家不需要插值
        _buffer.Enqueue(new TransformSnapshot
        {
            time = Time.time,
            position = pos,
            rotation = rot
        });
    }

    void Update()
    {
        if (IsOwner || _buffer.Count < 2) return;

        float renderTime = Time.time - BufferDelay;

        // 找到插值区间
        TransformSnapshot from = _buffer.Peek();
        TransformSnapshot to = default;

        foreach (var snap in _buffer)
        {
            if (snap.time <= renderTime) from = snap;
            else { to = snap; break; }
        }

        if (to.time == 0) return;

        float t = Mathf.InverseLerp(from.time, to.time, renderTime);
        transform.position = Vector3.Lerp(from.position, to.position, t);
        transform.rotation = Quaternion.Slerp(from.rotation, to.rotation, t);
    }
}

public class ClientPrediction : NetworkBehaviour
{
    private Rigidbody _rb;
    private Vector3 _serverPosition;
    private bool _hasCorrection;

    void Update()
    {
        if (!IsOwner) return;

        // 1. 本地立即执行输入（预测）
        Vector3 input = new Vector3(
            Input.GetAxisRaw("Horizontal"), 0,
            Input.GetAxisRaw("Vertical")
        );
        _rb.MovePosition(transform.position + input * 5f * Time.deltaTime);

        // 2. 发送输入到服务器
        MoveServerRpc(input);

        // 3. 收到服务器校正后修正
        if (_hasCorrection)
        {
            float error = Vector3.Distance(transform.position, _serverPosition);
            transform.position = error > 1f
                ? _serverPosition                                          // 误差大：强制修正
                : Vector3.Lerp(transform.position, _serverPosition, 0.2f); // 误差小：平滑修正
            _hasCorrection = false;
        }
    }

    [ServerRpc]
    void MoveServerRpc(Vector3 input)
    {
        // 服务器执行权威逻辑
        _rb.MovePosition(transform.position + input * 5f * Time.deltaTime);
        // 广播权威位置给该客户端
        CorrectPositionClientRpc(transform.position);
    }

    [ClientRpc]
    void CorrectPositionClientRpc(Vector3 authoritative)
    {
        if (!IsOwner) return;
        _serverPosition = authoritative;
        _hasCorrection = true;
    }
}

public class CombatEffects : NetworkBehaviour
{
    [SerializeField] private ParticleSystem _hitEffect;
    [SerializeField] private AudioClip _hitSound;

    // 服务器判定命中后，通知所有客户端播放特效
    public void OnHit(Vector3 hitPoint)
    {
        if (!IsServer) return;
        PlayHitEffectClientRpc(hitPoint);
    }

    [ClientRpc]
    void PlayHitEffectClientRpc(Vector3 hitPoint)
    {
        _hitEffect.transform.position = hitPoint;
        _hitEffect.Play();
        AudioSource.PlayClipAtPoint(_hitSound, hitPoint);
    }

    // 客户端请求服务器执行技能
    [ServerRpc(RequireOwnership = true)]
    public void CastSkillServerRpc(int skillId, Vector3 targetPos)
    {
        // 服务器验证并执行
        SkillManager.Execute(skillId, targetPos, OwnerClientId);
    }
}

[AttributeName]          // 标记在类、方法、字段上
public void MyMethod() { }

public class MyNetworkObject : NetworkBehaviour
{
    // [ClientRpc] = 服务器调用，在所有客户端执行
    // 方法名必须以 ClientRpc 结尾
    [ClientRpc]
    public void PlayEffectClientRpc(Vector3 pos)
    {
        // 这段代码在每个客户端上运行
        Instantiate(effectPrefab, pos, Quaternion.identity);
    }

    // [ServerRpc] = 客户端调用，在服务器执行
    // 方法名必须以 ServerRpc 结尾
    [ServerRpc]
    public void RequestFireServerRpc(Vector3 direction)
    {
        // 这段代码只在服务器上运行
        SpawnBullet(direction);
    }
}

// 调用方式
void Update()
{
    if (IsServer)
        PlayEffectClientRpc(transform.position); // 服务器调用，广播到所有客户端

    if (IsOwner)
        RequestFireServerRpc(aimDirection);      // 客户端调用，发送到服务器
}

// 新写法
[Rpc(SendTo.ClientsAndHost)]
public void PlayEffectRpc(Vector3 pos) { }

[Rpc(SendTo.Server)]
public void RequestFireRpc(Vector3 dir) { }

// 旧写法（仍然支持）
[ClientRpc]
public void PlayEffectClientRpc(Vector3 pos) { }

[ServerRpc]
public void RequestFireServerRpc(Vector3 dir) { }

[System.Flags]
public enum PlayerDirtyFlags : uint
{
    None        = 0,
    Position    = 1 << 0,
    Rotation    = 1 << 1,
    Health      = 1 << 2,
    Mana        = 1 << 3,
    Animation   = 1 << 4,
}

public class PlayerState
{
    public Vector3 Position;
    public float Rotation;
    public int Health;
    public int Mana;
    public int AnimationId;

    private PlayerState _lastSent = new(); // 上次发送的快照
    private PlayerDirtyFlags _dirty;

    // 修改字段时标记脏
    public void SetPosition(Vector3 pos)
    {
        if (Position == pos) return;
        Position = pos;
        _dirty |= PlayerDirtyFlags.Position;
    }

    public void SetHealth(int hp)
    {
        if (Health == hp) return;
        Health = hp;
        _dirty |= PlayerDirtyFlags.Health;
    }

    // 序列化：只写入脏字段
    public byte[] SerializeDelta()
    {
        using var writer = new BinaryWriter(new MemoryStream());

        writer.Write((uint)_dirty); // 先写标记位

        if (_dirty.HasFlag(PlayerDirtyFlags.Position))
        {
            writer.Write(Position.x);
            writer.Write(Position.y);
            writer.Write(Position.z);
        }
        if (_dirty.HasFlag(PlayerDirtyFlags.Health))
            writer.Write(Health);
        if (_dirty.HasFlag(PlayerDirtyFlags.Mana))
            writer.Write(Mana);
        // ... 其他字段

        _dirty = PlayerDirtyFlags.None; // 清除脏标记
        return ((MemoryStream)writer.BaseStream).ToArray();
    }

    // 反序列化：根据标记位读取对应字段
    public void DeserializeDelta(byte[] data)
    {
        using var reader = new BinaryReader(new MemoryStream(data));

        var flags = (PlayerDirtyFlags)reader.ReadUInt32();

        if (flags.HasFlag(PlayerDirtyFlags.Position))
        {
            Position = new Vector3(
                reader.ReadSingle(),
                reader.ReadSingle(),
                reader.ReadSingle()
            );
        }
        if (flags.HasFlag(PlayerDirtyFlags.Health))
            Health = reader.ReadInt32();
        if (flags.HasFlag(PlayerDirtyFlags.Mana))
            Mana = reader.ReadInt32();
    }
}

public class SnapshotDelta
{
    // 完整快照
    public struct WorldSnapshot
    {
        public Dictionary<int, PlayerSnapshot> Players;
        public int Tick;
    }

    public struct PlayerSnapshot
    {
        public Vector3 Position;
        public int Health;
        public int Score;
    }

    private WorldSnapshot _baseline; // 客户端已确认的基准快照

    // 服务器：对比两个快照，生成差量包
    public byte[] GenerateDelta(WorldSnapshot from, WorldSnapshot to)
    {
        using var writer = new BinaryWriter(new MemoryStream());

        writer.Write(to.Tick);

        foreach (var (id, toPlayer) in to.Players)
        {
            // 新增玩家
            if (!from.Players.TryGetValue(id, out var fromPlayer))
            {
                writer.Write((byte)DeltaOp.Add);
                writer.Write(id);
                WriteFullPlayer(writer, toPlayer);
                continue;
            }

            // 对比变化
            PlayerDirtyFlags dirty = PlayerDirtyFlags.None;
            if (fromPlayer.Position != toPlayer.Position) dirty |= PlayerDirtyFlags.Position;
            if (fromPlayer.Health   != toPlayer.Health)   dirty |= PlayerDirtyFlags.Health;
            if (fromPlayer.Score    != toPlayer.Score)    dirty |= PlayerDirtyFlags.Score;

            if (dirty != PlayerDirtyFlags.None)
            {
                writer.Write((byte)DeltaOp.Update);
                writer.Write(id);
                writer.Write((uint)dirty);
                if (dirty.HasFlag(PlayerDirtyFlags.Position)) WriteVector3(writer, toPlayer.Position);
                if (dirty.HasFlag(PlayerDirtyFlags.Health))   writer.Write(toPlayer.Health);
            }
        }

        // 离开的玩家
        foreach (var id in from.Players.Keys)
        {
            if (!to.Players.ContainsKey(id))
            {
                writer.Write((byte)DeltaOp.Remove);
                writer.Write(id);
            }
        }

        return ((MemoryStream)writer.BaseStream).ToArray();
    }

    enum DeltaOp : byte { Add, Update, Remove }
}

public static class PositionCompressor
{
    // 全量：Vector3 = 12字节
    // 压缩后：只发变化量，用short存，约4-6字节

    private const float Precision = 0.01f; // 1cm精度
    private const float MaxDelta = 32767 * Precision; // short最大值对应的距离

    // 发送位置差值而不是绝对值
    public static short[] CompressDelta(Vector3 from, Vector3 to)
    {
        Vector3 delta = to - from;
        return new short[]
        {
            (short)(delta.x / Precision),
            (short)(delta.y / Precision),
            (short)(delta.z / Precision)
        };
        // 3个short = 6字节，比12字节少一半
    }

    public static Vector3 DecompressDelta(Vector3 baseline, short[] delta)
    {
        return baseline + new Vector3(
            delta[0] * Precision,
            delta[1] * Precision,
            delta[2] * Precision
        );
    }
}

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// Simple GET endpoint returning a string
app.MapGet("/", () => "Hello World!");

// GET endpoint with a route parameter
app.MapGet("/products/{id}", (int id) => $"Returning product {id}");

// POST endpoint that accepts a JSON object (Todo item)
app.MapPost("/todoitems", (Todo todo) => 
    Results.Created($"/todoitems/{todo.Id}", todo));

app.Run();

// Data model for the POST example
public record Todo(int Id, string Name, bool IsComplete);

public class MyService
{
    private readonly IHttpClientFactory _httpClientFactory;

    public MyService(IHttpClientFactory httpClientFactory)
    {
        _httpClientFactory = httpClientFactory;
    }

    public async Task<string> GetExternalDataAsync()
    {
        // 1. Create the client
        var client = _httpClientFactory.CreateClient();

        // 2. Make the GET request
        var response = await client.GetAsync("https://api.example.com");

        // 3. Ensure success and read content
        if (response.IsSuccessStatusCode)
        {
            return await response.Content.ReadAsStringAsync();
        }

        return "Error fetching data";
    }
}

public class Singleton {
    private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class Singleton {
    private static final Singleton instance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
        return instance;
    }
}

using UnityEngine;
using System;
 
public class Publisher : MonoBehaviour
{
    // 声明一个事件
    public static event Action OnEventPublished;
 
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            // 发布事件
            OnEventPublished?.Invoke();
        }
    }
}
 
public class Subscriber : MonoBehaviour
{
    private void OnEnable()
    {
        // 订阅事件
        Publisher.OnEventPublished += HandleEvent;
    }
 
    private void OnDisable()
    {
        // 取消订阅事件
        Publisher.OnEventPublished -= HandleEvent;
    }
 
    // 事件处理方法
    private void HandleEvent()
    {
        Debug.Log("Event received!");
    }
}

delegate void IntMethodInvoker(int x);

Action
Action<in T>
Action<in t1,in t2>
Action<in t1,in t2,···,t16>

Func<out TResult>
Func<in t,out TResult>
Function<in t1,in t2,···,in t16,out TResult>

Func<int,int,int> plus = delegate(int a, int b)
{
  int temp = a+b;
  return temp;
}
int res = plus(34,34)
Console.WriteLine(res);

//上述代码可以换成下面一行
Func<int, int, int> plus = (a, b) => { return a + b; };

// 声明该事件的委托类型：事件名 + EventHandler
public delegate void OrderEventHandler(Customer customer, OrderEventArgs e);//声明一个委托类型

// 声明事件：访问修饰符 + event + 事件处理器（委托类型的实例、字段）+ 事件名称（一定要注意命名规范：On+事件名）
public event OrderEventHandler OnOrder;

public delegate void EventHandler(object? sender, EventArgs e);

Customer customer1 = _sender as Customer;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
/// <summary>
/// 事件的拥有者：顾客
/// 事件：点单
/// 事件的响应者：服务员
/// 事件处理器：计算最后金额
/// 事件订阅（+=操作符）
/// </summary>
namespace EventDemo
{
    //声明一个委托类型
    public delegate void OrderEventHandler(Customer customer, OrderEventArgs e);

    class EventExample
    {
        public static Customer customer = new Customer();
        public static Customer customer2 = new Customer();
        public static Waiter waiter = new Waiter();
        static void Main()
        {
            customer.OnOrder += waiter.CalculateBill;
            customer2.OnOrder += waiter.CalculateBill;
 
            //使用事件，事件只能由事件拥有者触发，不能在外部去触发
            //顾客1点了超大杯摩卡15+6 = 21
            customer.Order("摩卡", 15, OrderEventArgs.CoffeeSizeEnum.Venti);
            //顾客1点了中杯拿铁20
            customer.Order("拿铁", 20, OrderEventArgs.CoffeeSizeEnum.Tall);
            //顾客2点了中杯卡布奇诺
            customer2.Order("卡布奇诺", 25, OrderEventArgs.CoffeeSizeEnum.Tall);
            customer.PayTheBill();
            customer2.PayTheBill();
 
            /*//如果使用委托，不使用事件，委托类型的字段可以在外部进行调用，意味着顾客2可以把自己点的东西记在顾客1的账单上
            //顾客1点了超大杯摩卡15+6 = 21
            OrderEventArgs e1 = new OrderEventArgs();
            e1.CoffeeName = "摩卡";
            e1.CoffeePrice = 15;
            e1.CoffeeSize = OrderEventArgs.CoffeeSizeEnum.Venti;
            customer.OnOrder(customer, e1);
            //顾客1点了超大杯拿铁20+6 = 26，并记在了倒霉蛋顾客1的账单上
            OrderEventArgs e2 = new OrderEventArgs();
            e2.CoffeeName = "拿铁";
            e2.CoffeePrice = 20;
            e2.CoffeeSize = OrderEventArgs.CoffeeSizeEnum.Venti;
            customer2.OnOrder(customer, e2);
            customer.PayTheBill();
            customer2.PayTheBill();*/
 
 
            Console.Read();
        }
    }

    public class Customer
    {
        //声明一个点单事件
        public event OrderEventHandler OnOrder;

        public float Bill { get; set; }
        public void PayTheBill()
        {
            Console.WriteLine("I have to pay : " + Bill);
        }

        /// <summary>
        /// 点餐（咖啡名称、价格、大小）
        /// </summary>
        /// <param name="coffeeName"></param>
        /// <param name="coffeePrice"></param>
        /// <param name="coffeeSize"></param>
        public void Order(string coffeeName,float coffeePrice, OrderEventArgs.CoffeeSizeEnum coffeeSize)
        {
            //语法糖：如果事件不为空（因为简略声明事件时委托类型的字段被隐藏了）
            if (OnOrder != null)
            {
                OrderEventArgs e = new OrderEventArgs();
                e.CoffeeName = coffeeName;
                e.CoffeePrice = coffeePrice;
                e.CoffeeSize = coffeeSize;
                //事件只能由事件拥有者触发：限制只能自己给自己点单
                OnOrder(this, e);
            }
        }
    }

    public class Waiter
    {
        //计算账单金额
        public void CalculateBill(Customer customer, OrderEventArgs e)
        {
            float finalPrice = 0;
            switch (e.CoffeeSize)
            {
                case OrderEventArgs.CoffeeSizeEnum.Tall:
                    finalPrice = e.CoffeePrice; //中杯，原价
                    break;
                case OrderEventArgs.CoffeeSizeEnum.Grand:
                    finalPrice = e.CoffeePrice + 3; //大杯：原价+3元
                    break;
                case OrderEventArgs.CoffeeSizeEnum.Venti:
                    finalPrice = e.CoffeePrice + 6; //超大杯：原价+6元
                    break;
            }
            customer.Bill += finalPrice;
        }
    }

    public class OrderEventArgs
    {
        // 咖啡是大杯、中杯还是小杯
        public enum CoffeeSizeEnum { Tall,Grand,Venti}//默认为静态
        public CoffeeSizeEnum CoffeeSize { get; set; }
        // 咖啡价格
        public float CoffeePrice { get; set; }
        // 咖啡名称
        public string CoffeeName { get; set; }
    }
}