746 lines
22 KiB
C#
746 lines
22 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Cysharp.Threading.Tasks;
|
|
using Framework;
|
|
using Framework.Wrapper;
|
|
using Gameplay;
|
|
using Gameplay.Character;
|
|
using Gameplay.Common;
|
|
using Gameplay.Effect;
|
|
using Gameplay.Level;
|
|
using Gameplay.Net;
|
|
using Gameplay.Unit;
|
|
using Gameplay.Utils;
|
|
using Gameplay.Vehicle.Impl;
|
|
using PhxhSDK;
|
|
using TGS;
|
|
using UnityEngine;
|
|
using Action = BehaviorDesigner.Runtime.Tasks.Action;
|
|
using Constants = PhxhSDK.Constants;
|
|
using Object = UnityEngine.Object;
|
|
|
|
/// <summary>
|
|
/// 用于布阵
|
|
/// </summary>
|
|
public class PrepareTeamManager : Singlenton<PrepareTeamManager>
|
|
{
|
|
private const string STAGE_ROOT_NAME = "StageRoot";
|
|
|
|
private Map _map;
|
|
private int _prepareRegionId;
|
|
private int _enemyPrepareRegionId;
|
|
private LevelData.CharacterToward _toward;
|
|
private TerrainGridSystem _tgs;
|
|
private Quaternion _rotation;
|
|
private bool _hasInit;
|
|
private Transform _stageRoot;
|
|
|
|
public const int MaxOnFightNum = 6;
|
|
|
|
private List<PVPUnitInfo> _pvpUnitInfos; //已上阵的阵容
|
|
public List<PVPUnitInfo> PvpUnitInfos => _pvpUnitInfos;
|
|
|
|
private int _onFightVehicleID; //已上阵载具ID
|
|
private List<int> _onFightCharIDs = new(); //已上阵角色ID
|
|
|
|
private Dictionary<string, int> _LoadedAssets = new();
|
|
|
|
//key:cellIndex
|
|
private Dictionary<int, GameObject> _onStageUnits = new();
|
|
|
|
//key:prefabPath
|
|
private Dictionary<string, List<GameObject>> _modelPool = new();
|
|
|
|
private Dictionary<GameObject, string> _gameObjectToPathDic = new();
|
|
|
|
private EffectPlayingData _selectGFX; //特效数据对象
|
|
|
|
#region API
|
|
|
|
public event Action<int, string> OnAddModel;
|
|
|
|
public event Action<int> OnRemoveModel;
|
|
|
|
public event Action<int, int> OnSwapModel;
|
|
|
|
//当前选择的预制体
|
|
public string CurrPrefabPath { get; set; }
|
|
|
|
//是否可以放置多个相同预制
|
|
public bool CanMultiple { get; set; }
|
|
|
|
public void Init(TerrainGridSystem tgs, MapData mapData, int prepareRegionID, LevelData.CharacterToward toward,
|
|
Camera camera, int enemyPrepareRegionID, Dictionary<int, string> _initPrepareInfo = null)
|
|
{
|
|
if (_hasInit)
|
|
Dispose();
|
|
_tgs = tgs;
|
|
_map = MapUtils.LoadMap(tgs, mapData);
|
|
MapUtils.BindCameraController(camera, _map);
|
|
_tgs.showCells = true;
|
|
if (prepareRegionID < 0 || prepareRegionID >= mapData.regions.Count)
|
|
{
|
|
Debug.LogError($"找不到region!,regionID:{prepareRegionID}");
|
|
return;
|
|
}
|
|
|
|
if (enemyPrepareRegionID < 0 || enemyPrepareRegionID >= mapData.regions.Count)
|
|
{
|
|
Debug.LogError($"找不到region!,regionID:{prepareRegionID}");
|
|
return;
|
|
}
|
|
|
|
_prepareRegionId = prepareRegionID;
|
|
_enemyPrepareRegionId = enemyPrepareRegionID;
|
|
_toward = toward;
|
|
_rotation = Quaternion.Euler(new Vector3(0, LevelUtils.SetCharaterToward(_toward), 0));
|
|
_hasInit = true;
|
|
_stageRoot = new GameObject(STAGE_ROOT_NAME).transform;
|
|
RevertPreparedModels(_initPrepareInfo);
|
|
InputManager.Instance.OnClick += OnClick;
|
|
ShowEnemyPrepareRegion();
|
|
ShowPrepareRegion();
|
|
RegisterEvents();
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_hasInit = false;
|
|
_map = null;
|
|
_tgs = null;
|
|
_onStageUnits.Clear();
|
|
_modelPool.Clear();
|
|
_gameObjectToPathDic.Clear();
|
|
Object.Destroy(_stageRoot.gameObject);
|
|
_stageRoot = null;
|
|
InputManager.Instance.OnClick -= OnClick;
|
|
OnAddModel = null;
|
|
OnRemoveModel = null;
|
|
OnSwapModel = null;
|
|
CurrPrefabPath = null;
|
|
CanMultiple = false;
|
|
_selectGFX = null;
|
|
//_pvpUnitInfos.Clear();
|
|
_onFightCharIDs.Clear();
|
|
_onFightVehicleID = 0;
|
|
_UnLoadAssets();
|
|
UnRegisterEvents();
|
|
}
|
|
|
|
private void RegisterEvents()
|
|
{
|
|
EventManager.Instance.Register(EventManager.EventName.Level_OnClick, (Action<Vector2>) OnClick);
|
|
}
|
|
|
|
private void UnRegisterEvents()
|
|
{
|
|
EventManager.Instance.Unregister(EventManager.EventName.Level_OnClick, (Action<Vector2>) OnClick);
|
|
}
|
|
#region Model
|
|
|
|
//之前已经布置过的模型重新放置上来
|
|
public void RevertPreparedModels(Dictionary<int, string> preparedData)
|
|
{
|
|
if (preparedData == null)
|
|
return;
|
|
foreach (var kv in preparedData)
|
|
{
|
|
AddModel(kv.Value, kv.Key);
|
|
}
|
|
}
|
|
|
|
public void AutoAddModel(string path, int cellIndex)
|
|
{
|
|
AddModel(path, cellIndex);
|
|
}
|
|
|
|
public void ShowPrepareRegion()
|
|
{
|
|
_tgs.showCells = true;
|
|
//todo 颜色从配置中获取
|
|
_map.SetRegionColor(_prepareRegionId, true, ColorEx.FromStr("#FF960072"));
|
|
}
|
|
|
|
public void ShowEnemyPrepareRegion()
|
|
{
|
|
_map.SetRegionColor(_enemyPrepareRegionId, true, ColorEx.FromStr("#EC808D"));
|
|
}
|
|
|
|
public void HidePrepareRegion()
|
|
{
|
|
_tgs.showCells = false;
|
|
_map.SetRegionColor(_prepareRegionId, false, ColorEx.FromStr("#FF960072"));
|
|
}
|
|
|
|
public void ShowSelectFlag()
|
|
{
|
|
|
|
}
|
|
|
|
private async UniTask<T> _LoadAssetAsync<T>(string path) where T : Object
|
|
{
|
|
var asset = await AssetManager.Instance.LoadAssetAsync<T>(path);
|
|
if (!asset)
|
|
return null;
|
|
if (_LoadedAssets.ContainsKey(path))
|
|
{
|
|
++_LoadedAssets[path];
|
|
}
|
|
else
|
|
{
|
|
_LoadedAssets.Add(path, 1);
|
|
}
|
|
|
|
return asset;
|
|
}
|
|
|
|
private void _UnLoadAssets()
|
|
{
|
|
foreach (var kv in _LoadedAssets)
|
|
{
|
|
var path = kv.Key;
|
|
var count = kv.Value;
|
|
for (int i = count; i > 0; --i)
|
|
{
|
|
AssetManager.Instance.Unload(path);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
private void OnClick(Vector2 screenPos)
|
|
{
|
|
var cellIndex = GroundHitHelper.CalcHitCellIndex(screenPos, _tgs);
|
|
//点击非出战区
|
|
if (!_map.MapData.IsCellInsideRegion(cellIndex, _prepareRegionId))
|
|
{
|
|
CurrPrefabPath = null;
|
|
EventManager.Instance.Send(EventManager.EventName.OnUnSelectPvPUnit);
|
|
_HideSelectView();
|
|
return;
|
|
}
|
|
|
|
//未选中时点击格子
|
|
if (string.IsNullOrEmpty(CurrPrefabPath) && _onStageUnits.ContainsKey(cellIndex))
|
|
{
|
|
var unitInfo = _pvpUnitInfos.Find(unit => unit.cellIndex == cellIndex);
|
|
if (unitInfo != null)
|
|
{
|
|
EventManager.Instance.Send(EventManager.EventName.OnSelectPvPUnit, unitInfo.unitID);
|
|
}
|
|
|
|
_ShowSelectView(cellIndex);
|
|
return;
|
|
}
|
|
_HideSelectView();
|
|
if (cellIndex >= 0 && _map.MapData.IsCellInsideRegion(cellIndex, _prepareRegionId) &&
|
|
!string.IsNullOrEmpty(CurrPrefabPath))
|
|
{
|
|
//获得当前选择模型在台上的index
|
|
var currPrefabOnStageIndex = GetCellIndexOnStage(CurrPrefabPath);
|
|
|
|
if (_onStageUnits.TryGetValue(cellIndex, out var go))
|
|
{
|
|
//如果点击的位置已经有模型了
|
|
var pathOnStage = GameObjectToPath(go);
|
|
if (pathOnStage == CurrPrefabPath)
|
|
{
|
|
//台上的模型路径和当前选择的路径相同 下阵
|
|
|
|
RemoveModel(cellIndex);
|
|
EventManager.Instance.Send(EventManager.EventName.OnPVPUnitRemove);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (currPrefabOnStageIndex >= 0 && !CanMultiple)
|
|
{
|
|
//如果台上已经有当前选择模型，则和点击位置的模型(可能是空)互换位置
|
|
SwapModel(currPrefabOnStageIndex, cellIndex);
|
|
EventManager.Instance.Send(EventManager.EventName.OnUnSelectPvPUnit);
|
|
_HideSelectView();
|
|
}
|
|
else
|
|
{
|
|
//如果台上没有当前选择的模型，则替换掉当前点击位置的模型
|
|
if (!_onStageUnits.ContainsKey(cellIndex))
|
|
{
|
|
if (UI_DefendSettingController.SelectID > 0)
|
|
{
|
|
bool isLimited = false;
|
|
if (_CheckIsCharacter(UI_DefendSettingController.SelectID))
|
|
{
|
|
if (CheckIsCharacterCountLimit())
|
|
{
|
|
isLimited = true;
|
|
}
|
|
}
|
|
|
|
if(_CheckIsVehicle(UI_DefendSettingController.SelectID))
|
|
{
|
|
if (CheckIsVehicleCountLimit())
|
|
{
|
|
isLimited = true;
|
|
}
|
|
}
|
|
|
|
if (_CheckIsBuilding(UI_DefendSettingController.SelectID))
|
|
{
|
|
if (CheckIsBuildingCountLimit())
|
|
{
|
|
isLimited = true;
|
|
}
|
|
}
|
|
|
|
if (isLimited)
|
|
{
|
|
UITipsManager.ShowTips(CommonUtils.GetLocalizeText("pvp_count_limit"));
|
|
EventManager.Instance.Send(EventManager.EventName.OnUnSelectPvPUnit);
|
|
_HideSelectView();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//车换人/人换车
|
|
if (_onStageUnits.ContainsKey(cellIndex))
|
|
{
|
|
if (UI_DefendSettingController.SelectID > 0)
|
|
{
|
|
bool isLimited = false;
|
|
var unitInfo = _pvpUnitInfos.Find(unit => unit.cellIndex == cellIndex);
|
|
if (unitInfo != null)
|
|
{
|
|
if (_CheckIsCharacter(UI_DefendSettingController.SelectID))
|
|
{
|
|
if (unitInfo.type == Unit.UnitType.Vehicle)
|
|
{
|
|
if (CheckIsCharacterCountLimit())
|
|
{
|
|
isLimited = true;
|
|
}
|
|
}
|
|
|
|
if (unitInfo.type == Unit.UnitType.Building)
|
|
{
|
|
if (CheckIsCharacterCountLimit())
|
|
{
|
|
isLimited = true;
|
|
}
|
|
}
|
|
}
|
|
if (_CheckIsVehicle(UI_DefendSettingController.SelectID))
|
|
{
|
|
if (unitInfo.type == Unit.UnitType.Charactor)
|
|
{
|
|
if (CheckIsVehicleCountLimit())
|
|
{
|
|
isLimited = true;
|
|
}
|
|
}
|
|
|
|
if (unitInfo.type == Unit.UnitType.Building)
|
|
{
|
|
if (CheckIsVehicleCountLimit())
|
|
{
|
|
isLimited = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_CheckIsBuilding(UI_DefendSettingController.SelectID))
|
|
{
|
|
if (unitInfo.type == Unit.UnitType.Charactor)
|
|
{
|
|
if (CheckIsBuildingCountLimit())
|
|
{
|
|
isLimited = true;
|
|
}
|
|
}
|
|
|
|
if (unitInfo.type == Unit.UnitType.Vehicle)
|
|
{
|
|
if (CheckIsBuildingCountLimit())
|
|
{
|
|
isLimited = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isLimited)
|
|
{
|
|
UITipsManager.ShowTips(CommonUtils.GetLocalizeText("pvp_count_limit"));
|
|
EventManager.Instance.Send(EventManager.EventName.OnUnSelectPvPUnit);
|
|
_HideSelectView();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
AddModel(CurrPrefabPath, cellIndex);
|
|
EventManager.Instance.Send(EventManager.EventName.OnUnSelectPvPUnit);
|
|
_HideSelectView();
|
|
}
|
|
}
|
|
}
|
|
|
|
private string GameObjectToPath(GameObject go)
|
|
{
|
|
return _gameObjectToPathDic.GetValueOrDefault(go);
|
|
}
|
|
|
|
private int GetCellIndexOnStage(string prefabPath)
|
|
{
|
|
foreach (var kv in _onStageUnits)
|
|
{
|
|
var cellIndex = kv.Key;
|
|
var go = kv.Value;
|
|
if (_gameObjectToPathDic[go] == prefabPath)
|
|
{
|
|
return cellIndex;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
private async UniTask<GameObject> GetAModel(string prefabPath)
|
|
{
|
|
GameObject model = null;
|
|
if (_modelPool.TryGetValue(prefabPath, out var modelList))
|
|
{
|
|
if (modelList.Count > 0)
|
|
{
|
|
model = modelList[^1];
|
|
modelList.RemoveAt(modelList.Count - 1);
|
|
}
|
|
}
|
|
|
|
if (model == null)
|
|
{
|
|
var go = await _LoadAssetAsync<GameObject>(prefabPath);
|
|
model = Object.Instantiate(go, _stageRoot);
|
|
_gameObjectToPathDic.Add(model, prefabPath);
|
|
}
|
|
|
|
return model;
|
|
}
|
|
|
|
private void ReturnModelToPool(GameObject model)
|
|
{
|
|
var path = _gameObjectToPathDic[model];
|
|
if (!_modelPool.TryGetValue(path, out var modelList))
|
|
{
|
|
modelList = new();
|
|
_modelPool.Add(path, modelList);
|
|
}
|
|
|
|
modelList.Add(model);
|
|
}
|
|
|
|
private async void AddModel(string prefabPath, int cellIndex)
|
|
{
|
|
if (_onStageUnits.ContainsKey(cellIndex))
|
|
{
|
|
RemoveModel(cellIndex);
|
|
}
|
|
|
|
OnAddModel?.Invoke(cellIndex, prefabPath);
|
|
var model = await GetAModel(prefabPath);
|
|
model.SetActive(true);
|
|
model.SetLayerEx(LayerMask.NameToLayer("UIView"));
|
|
// var animTrans = model.transform.GetChild(0);
|
|
// if (animTrans)
|
|
// {
|
|
// var anim = animTrans.GetComponent<Animator>();
|
|
// if (anim)
|
|
// {
|
|
// anim.Play("idle");
|
|
// }
|
|
// }
|
|
SetModelPosition(model, cellIndex);
|
|
_onStageUnits.Add(cellIndex, model);
|
|
}
|
|
|
|
private void RemoveModel(int cellIndex)
|
|
{
|
|
if (_onStageUnits.TryGetValue(cellIndex, out var model))
|
|
{
|
|
model.SetActive(false);
|
|
_onStageUnits.Remove(cellIndex);
|
|
ReturnModelToPool(model);
|
|
OnRemoveModel?.Invoke(cellIndex);
|
|
}
|
|
}
|
|
|
|
private void SwapModel(int cellIndexLeft, int cellIndexRight)
|
|
{
|
|
if (cellIndexLeft == cellIndexRight ||
|
|
!_map.MapData.IsCellInsideRegion(cellIndexLeft, _prepareRegionId) ||
|
|
!_map.MapData.IsCellInsideRegion(cellIndexRight, _prepareRegionId))
|
|
return;
|
|
var leftModel = _onStageUnits.GetValueOrDefault(cellIndexLeft);
|
|
var rightModel = _onStageUnits.GetValueOrDefault(cellIndexRight);
|
|
|
|
_onStageUnits.Remove(cellIndexLeft);
|
|
_onStageUnits.Remove(cellIndexRight);
|
|
|
|
var unitLeft = _pvpUnitInfos.Find(unit => unit.cellIndex == cellIndexLeft);
|
|
var unitRight = _pvpUnitInfos.Find(unit => unit.cellIndex == cellIndexRight);
|
|
if (leftModel != null)
|
|
{
|
|
if (unitLeft != null)
|
|
{
|
|
unitLeft.cellIndex = cellIndexRight;
|
|
}
|
|
_onStageUnits.Add(cellIndexRight, leftModel);
|
|
SetModelPosition(leftModel, cellIndexRight);
|
|
}
|
|
|
|
if (rightModel != null)
|
|
{
|
|
if (unitRight != null)
|
|
{
|
|
unitRight.cellIndex = cellIndexLeft;
|
|
}
|
|
_onStageUnits.Add(cellIndexLeft, rightModel);
|
|
SetModelPosition(rightModel, cellIndexLeft);
|
|
}
|
|
|
|
OnSwapModel?.Invoke(cellIndexLeft, cellIndexRight);
|
|
}
|
|
|
|
private void SetModelPosition(GameObject model, int cellIndex)
|
|
{
|
|
var positionWS = _map.TGSCellIndex2WorldPosition(cellIndex);
|
|
model.transform.SetPositionAndRotation(positionWS, _rotation);
|
|
}
|
|
#endregion
|
|
|
|
#region Data
|
|
private void _AddUnit(PVPUnitInfo unit)
|
|
{
|
|
_pvpUnitInfos?.Add(unit);
|
|
}
|
|
|
|
private void _RemoveUnit(PVPUnitInfo unit)
|
|
{
|
|
_pvpUnitInfos?.Remove(unit);
|
|
}
|
|
|
|
private void _InitUnitInfos()
|
|
{
|
|
if (_pvpUnitInfos == null)
|
|
{
|
|
_pvpUnitInfos = new();
|
|
}
|
|
else
|
|
{
|
|
_pvpUnitInfos.Clear();
|
|
}
|
|
_pvpUnitInfos.AddRange(PVPUnitInfo.ParseMyPvpDefenceData());
|
|
}
|
|
|
|
private PVPUnitInfo _CreatePVPUnitInfo(int cellIndex, uint id)
|
|
{
|
|
PVPUnitInfo unitInfo = new PVPUnitInfo();
|
|
var allCharacterInfosDic = CharacterDataInfoManager.Instance.DataDic;
|
|
var allVehicleDic = VehicleCultivateDataManager.Instance.DataDic;
|
|
var allBuildingDic = FightBuildingDataManager.Instance.DataDic;
|
|
unitInfo.unitID = id;
|
|
if (allCharacterInfosDic.ContainsKey(id))
|
|
{
|
|
unitInfo.type = Unit.UnitType.Charactor;
|
|
}
|
|
|
|
else if (allVehicleDic.ContainsKey(id))
|
|
{
|
|
unitInfo.type = Unit.UnitType.Vehicle;
|
|
}
|
|
|
|
else if (allBuildingDic.ContainsKey(id))
|
|
{
|
|
unitInfo.type = Unit.UnitType.Building;
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
//unitInfo.type = allCharacterInfosDic.ContainsKey(id)? Unit.UnitType.Charactor : Unit.UnitType.Vehicle;
|
|
unitInfo.cellIndex = cellIndex;
|
|
return unitInfo;
|
|
}
|
|
|
|
|
|
private bool _CheckIsCharacter(uint uid)
|
|
{
|
|
return CharacterDataInfoManager.Instance.DataDic.ContainsKey(uid);
|
|
}
|
|
|
|
private bool _CheckIsVehicle(uint uid)
|
|
{
|
|
return VehicleCultivateDataManager.Instance.DataDic.ContainsKey(uid);
|
|
}
|
|
|
|
private bool _CheckIsBuilding(uint uid)
|
|
{
|
|
return FightBuildingDataManager.Instance.DataDic.ContainsKey(uid);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SelectView
|
|
|
|
private void _ShowSelectView(int cellIndex)
|
|
{
|
|
if (_selectGFX == null)
|
|
{
|
|
_selectGFX = _GetSelectGFXObj();
|
|
}
|
|
|
|
var pos = _GetSelectCellPos(cellIndex);
|
|
_selectGFX.transform.position = pos;
|
|
_selectGFX.rootObj.SetLayerEx(LayerDefine.UIView);
|
|
_selectGFX.SetActive(true);
|
|
}
|
|
|
|
private void _HideSelectView()
|
|
{
|
|
if (_selectGFX == null)
|
|
{
|
|
return;
|
|
}
|
|
_selectGFX.SetActive(false);
|
|
}
|
|
|
|
private EffectPlayingData _GetSelectGFXObj()
|
|
{
|
|
if (_selectGFX == null)
|
|
{
|
|
_selectGFX = EffectManager.instance.PlayEffectById(Framework.Constants.EID_CHARACTER_SELECT);
|
|
_selectGFX.SetActive(false);
|
|
}
|
|
|
|
return _selectGFX;
|
|
}
|
|
|
|
private Vector3 _GetSelectCellPos(int cellIndex)
|
|
{
|
|
return _map.TGSCellIndex2WorldPosition(cellIndex);
|
|
}
|
|
#endregion
|
|
|
|
#region API
|
|
|
|
public PVPUnitInfo CreateUnitInfo(int cellIndex, uint id)
|
|
{
|
|
return _CreatePVPUnitInfo(cellIndex, id);
|
|
}
|
|
|
|
public void AddUnit(PVPUnitInfo unit)
|
|
{
|
|
_AddUnit(unit);
|
|
}
|
|
|
|
public void RemoveUnit(PVPUnitInfo unit)
|
|
{
|
|
_RemoveUnit(unit);
|
|
}
|
|
|
|
public void InitUnitInfos()
|
|
{
|
|
_InitUnitInfos();
|
|
}
|
|
|
|
public void OnSelectUnit(uint uid)
|
|
{
|
|
EventManager.Instance.Send(EventManager.EventName.OnSelectPvPUnit, uid);
|
|
}
|
|
|
|
public void OnCancelSelectUnit()
|
|
{
|
|
EventManager.Instance.Send(EventManager.EventName.OnUnSelectPvPUnit);
|
|
}
|
|
|
|
public void RemoveAllModels()
|
|
{
|
|
var keyList = _onStageUnits.Keys.ToList();
|
|
foreach (var cell in keyList)
|
|
{
|
|
RemoveModel(cell);
|
|
}
|
|
}
|
|
|
|
public bool CheckIsCharacterCountLimit()
|
|
{
|
|
if (_pvpUnitInfos?.Count < GLConfig.Inst.data.PvpDefenderMaxNumber)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (_pvpUnitInfos != null)
|
|
{
|
|
var count = 0;
|
|
foreach (var unit in _pvpUnitInfos)
|
|
{
|
|
if (unit.type == Unit.UnitType.Charactor)
|
|
{
|
|
++count;
|
|
}
|
|
}
|
|
|
|
return count >= GLConfig.Inst.data.PvpFightCharacterLimit;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool CheckIsVehicleCountLimit()
|
|
{
|
|
if (_pvpUnitInfos != null)
|
|
{
|
|
var count = 0;
|
|
foreach (var unit in _pvpUnitInfos)
|
|
{
|
|
if (unit.type == Unit.UnitType.Vehicle)
|
|
{
|
|
++count;
|
|
}
|
|
}
|
|
|
|
return count >= GLConfig.Inst.data.PvpFightVehicleLimit;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool CheckIsBuildingCountLimit()
|
|
{
|
|
if (_pvpUnitInfos != null)
|
|
{
|
|
var count = 0;
|
|
foreach (var unit in _pvpUnitInfos)
|
|
{
|
|
if (unit.type == Unit.UnitType.Building)
|
|
{
|
|
++count;
|
|
}
|
|
}
|
|
|
|
return count >= GLConfig.Inst.data.PvpFightBuildLimit;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool CheckIsCellIndexBlank(int cellIndex)
|
|
{
|
|
if (_onStageUnits == null)
|
|
{
|
|
return false;
|
|
}
|
|
return !_onStageUnits.ContainsKey(cellIndex);
|
|
}
|
|
#endregion
|
|
} |