# 军团与营地系统优化建议

## 1. 军团系统优化

### 1.1 当前实现分析
```csharp
// LegionManager.cs 中的实现
public class LegionManager
{
    public LegionManager.Data data;
    private Dictionary<string, List<Mercenary>> _mercenaryMap;

    private void _OnInit()
    {
        _mercenaryMap = new Dictionary<string, List<Mercenary>>();
        // 初始化军团数据
    }
}

// LegionManager.Data.cs
public partial class LegionManager
{
    public class Data
    {
        public int level;
        public int exp;
        public List<MemberInfo> members;
        // 其他数据...
    }
}
```

### 1.2 优化建议
1. 实现军团数据缓存系统：
```csharp
public class LegionCacheSystem
{
    private Dictionary<string, LegionData> _legionCache = new();
    private LRUCache<string, MemberData> _memberCache;
    
    public async UniTask<LegionData> GetLegionData(string legionId)
    {
        if (_legionCache.TryGetValue(legionId, out var cachedData))
        {
            return cachedData;
        }
        
        var data = await LoadLegionData(legionId);
        _legionCache[legionId] = data;
        return data;
    }
    
    public void UpdateMemberCache(string memberId, MemberData data)
    {
        _memberCache.Set(memberId, data);
    }
}
```

2. 优化军团战斗系统：
```csharp
public class LegionBattleSystem
{
    private Dictionary<string, LegionBattleState> _battleStates = new();
    private Queue<LegionBattleRequest> _battleQueue = new();
    
    public async UniTask<LegionBattleResult> ProcessBattle(LegionBattleRequest request)
    {
        // 战斗请求排队
        _battleQueue.Enqueue(request);
        
        // 使用协程处理战斗
        return await ProcessBattleQueue();
    }
    
    private async UniTask<LegionBattleResult> ProcessBattleQueue()
    {
        while (_battleQueue.Count > 0)
        {
            var request = _battleQueue.Dequeue();
            var result = await ExecuteBattle(request);
            await SyncBattleResult(result);
        }
    }
}
```

## 2. 营地系统优化

### 2.1 当前问题
- 建筑放置性能
- 资源计算频繁
- 数据同步效率

### 2.2 优化建议
1. 实现网格管理系统：
```csharp
public class GridManager
{
    private CampCell[,] _grid;
    private Dictionary<int, Building> _buildings = new();
    private SpatialHashGrid _spatialHash;
    
    public bool TryPlaceBuilding(Building building, Vector2Int position)
    {
        if (!IsValidPlacement(building, position))
            return false;
            
        // 使用空间哈希快速检查碰撞
        if (_spatialHash.HasCollision(position, building.size))
            return false;
            
        PlaceBuilding(building, position);
        _spatialHash.UpdateBuilding(building);
        return true;
    }
    
    private bool IsValidPlacement(Building building, Vector2Int position)
    {
        // 使用位运算优化格子检查
        return (GetCellFlags(position) & building.placementFlags) == 0;
    }
}
```

2. 资源系统优化：
```csharp
public class ResourceSystem
{
    private Dictionary<ResourceType, float> _baseProduction = new();
    private Dictionary<ResourceType, List<ProductionModifier>> _modifiers = new();
    
    // 缓存计算结果
    private Dictionary<ResourceType, ResourceCalculation> _cachedCalculations = new();
    private float _lastCalculationTime;
    
    public float GetResourceProduction(ResourceType type)
    {
        var now = Time.time;
        if (now - _lastCalculationTime > updateInterval)
        {
            UpdateCalculations();
        }
        return _cachedCalculations[type].totalProduction;
    }
    
    private void UpdateCalculations()
    {
        foreach (var type in _baseProduction.Keys)
        {
            var calc = new ResourceCalculation();
            calc.baseValue = _baseProduction[type];
            
            // 应用修饰符
            foreach (var modifier in _modifiers[type])
            {
                modifier.Apply(ref calc);
            }
            
            _cachedCalculations[type] = calc;
        }
        _lastCalculationTime = Time.time;
    }
}
```

## 3. 数据同步优化

### 3.1 增量同步系统：
```csharp
public class IncrementalSyncSystem
{
    private Dictionary<string, object> _lastSyncState = new();
    private Queue<SyncOperation> _pendingOperations = new();
    
    public void RecordChange(string key, object newValue)
    {
        if (!_lastSyncState.ContainsKey(key) || !_lastSyncState[key].Equals(newValue))
        {
            _pendingOperations.Enqueue(new SyncOperation
            {
                key = key,
                value = newValue,
                timestamp = DateTime.UtcNow
            });
        }
    }
    
    public async UniTask SyncWithServer()
    {
        while (_pendingOperations.Count > 0)
        {
            var operation = _pendingOperations.Dequeue();
            await SendToServer(operation);
            _lastSyncState[operation.key] = operation.value;
        }
    }
}
```

### 3.2 批量更新系统：
```csharp
public class BatchUpdateSystem
{
    private List<UpdateOperation> _pendingUpdates = new();
    private float _batchTimeWindow = 0.1f; // 100ms
    private float _lastBatchTime;
    
    public void QueueUpdate(UpdateOperation operation)
    {
        _pendingUpdates.Add(operation);
        
        if (Time.time - _lastBatchTime >= _batchTimeWindow)
        {
            ProcessBatch();
        }
    }
    
    private void ProcessBatch()
    {
        // 合并相同类型的更新
        var mergedUpdates = MergeUpdates(_pendingUpdates);
        
        // 执行批量更新
        foreach (var update in mergedUpdates)
        {
            ExecuteUpdate(update);
        }
        
        _pendingUpdates.Clear();
        _lastBatchTime = Time.time;
    }
}
```

## 4. 性能优化建议

### 4.1 内存优化
1. 对象池化：
```csharp
public class CampObjectPool
{
    private Dictionary<Type, Queue<ICampObject>> _pools = new();
    
    public T Get<T>() where T : ICampObject, new()
    {
        var type = typeof(T);
        if (!_pools.ContainsKey(type))
        {
            _pools[type] = new Queue<ICampObject>();
        }
        
        var pool = _pools[type];
        if (pool.Count > 0)
        {
            return (T)pool.Dequeue();
        }
        
        return new T();
    }
    
    public void Return(ICampObject obj)
    {
        var type = obj.GetType();
        if (!_pools.ContainsKey(type))
        {
            _pools[type] = new Queue<ICampObject>();
        }
        
        obj.Reset();
        _pools[type].Enqueue(obj);
    }
}
```

### 4.2 计算优化
1. 区域效果计算：
```csharp
public class AreaEffectSystem
{
    private Dictionary<Vector2Int, List<AreaEffect>> _effectGrid = new();
    private SpatialHashGrid _spatialHash;
    
    public void UpdateAreaEffects()
    {
        // 使用Job System并行计算效果
        var job = new CalculateAreaEffectJob
        {
            effects = _effectGrid.ToNativeArray(),
            results = new NativeArray<float>(totalCells)
        };
        
        // 调度Job
        var handle = job.Schedule(_effectGrid.Count, 64);
        handle.Complete();
        
        // 更新结果
        ApplyEffectResults(job.results);
    }
}
```

## 5. 建议改进方向

### 5.1 军团系统
1. 数据管理
   - 实现分层缓存
   - 优化数据同步
   - 增加数据压缩

2. 功能优化
   - 军团战配对系统
   - 军团任务系统
   - 军团商店系统

3. 性能优化
   - 减少数据同步频率
   - 优化军团战战斗计算
   - 实现军团数据预加载

### 5.2 营地系统
1. 建筑系统
   - 优化建筑放置算法
   - 改进网格管理
   - 增加建筑互动功能

2. 资源系统
   - 优化资源计算
   - 实现资源预测
   - 添加资源事件系统

3. 性能优化
   - 实现区域效果缓存
   - 优化寻路系统
   - 改进资源计算方式

## 6. 注意事项

1. 数据一致性
   - 确保军团数据同步
   - 处理网络延迟问题
   - 实现数据冲突解决

2. 用户体验
   - 优化操作响应速度
   - 提供实时反馈
   - 减少加载等待时间

3. 扩展性
   - 保持系统模块化
   - 支持新功能快速接入
   - 维护良好的版本兼容性