695 lines
21 KiB
C#
695 lines
21 KiB
C#
using UnityEngine;
|
|
using System.Collections.Generic;
|
|
|
|
//using StateMachine;
|
|
|
|
public class FighterManager
|
|
{
|
|
#region Fields
|
|
BaseBattle mBattle;
|
|
List<Fighter> mTeamHeroFighters = new List<Fighter>();
|
|
List<Fighter> mTeamPetFighters = new List<Fighter>();
|
|
List<Fighter> mTeamFigters = new List<Fighter>();
|
|
List<Fighter> mEnemyFighters = new List<Fighter>();
|
|
List<Fighter> mAllFighters = new List<Fighter>();
|
|
|
|
List<Fighter> mBattleFieldFighters = new List<Fighter>();
|
|
List<Fighter> mCacheTeamFighters = new List<Fighter>();
|
|
#endregion
|
|
|
|
#region Properties
|
|
public Fighter self = null;
|
|
|
|
public BaseBattle Battle { get { return mBattle; } }
|
|
|
|
public bool IsDisposed { get; private set; }
|
|
|
|
public List<Fighter> AllFighters { get { return mAllFighters; } }
|
|
|
|
public List<Fighter> TeamFighters { get { return mTeamFigters; } }
|
|
|
|
public List<Fighter> TeamHeroFighters { get { return mTeamHeroFighters; } }
|
|
|
|
public List<Fighter> TeamPetFighters { get { return mTeamPetFighters; } }
|
|
|
|
public List<Fighter> EnemyFighters { get { return mEnemyFighters; } }
|
|
|
|
public List<Fighter> BattleFieldFighters { get { return mBattleFieldFighters; } }
|
|
|
|
public bool HasInitializedFighters { get; private set; }
|
|
|
|
public Fighter LeftCaptain { get; private set; }
|
|
|
|
public Fighter RightCaptain { get; private set; }
|
|
|
|
public ActorData[] AssistActors { get; private set; }
|
|
|
|
public int AssistValue { get; private set; }
|
|
|
|
public Vector3 TeamFighterFocus
|
|
{
|
|
get
|
|
{
|
|
if (mBattle.IsPlayRecord && mBattle.Recorder.SwapReplay)
|
|
{
|
|
if (EnemyFighters.Count == 0)
|
|
return Vector3.zero;
|
|
|
|
Vector3 min = Vector3.zero;
|
|
Vector3 max = Vector3.zero;
|
|
bool hasSet = false;
|
|
foreach (var fighter in EnemyFighters)
|
|
{
|
|
if (!fighter.IsSpawned || fighter.IsDisposed || !fighter.IsVisible)
|
|
continue;
|
|
if (!hasSet)
|
|
{
|
|
min = fighter.Ctrl.transform.position;
|
|
max = fighter.Ctrl.transform.position;
|
|
hasSet = true;
|
|
}
|
|
else
|
|
{
|
|
min = Vector3.Min(fighter.Ctrl.transform.position, min);
|
|
max = Vector3.Max(fighter.Ctrl.transform.position, max);
|
|
}
|
|
}
|
|
|
|
return 0.5f * (min + max) + Vector3.up * 1.0f;
|
|
}
|
|
else
|
|
{
|
|
if (TeamFighters.Count == 0)
|
|
return Vector3.zero;
|
|
|
|
Vector3 min = Vector3.zero;
|
|
Vector3 max = Vector3.zero;
|
|
bool hasSet = false;
|
|
for (int idx = 0; idx < TeamFighters.Count; idx++)
|
|
{
|
|
Fighter f = TeamFighters[idx];
|
|
if (!hasSet)
|
|
{
|
|
min = f.Position;
|
|
max = f.Position;
|
|
hasSet = true;
|
|
}
|
|
else
|
|
{
|
|
min = Vector3.Min(f.Position, min);
|
|
max = Vector3.Max(f.Position, max);
|
|
}
|
|
}
|
|
|
|
return 0.5f * (min + max) + Vector3.up * 1.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
public Vector3 TeamFighterForward
|
|
{
|
|
get
|
|
{
|
|
if (mBattle.IsPlayRecord && mBattle.Recorder.SwapReplay)
|
|
{
|
|
if (EnemyFighters.Count == 0)
|
|
return Vector3.forward;
|
|
return EnemyFighters[0].Ctrl != null ? EnemyFighters[0].Ctrl.transform.forward : EnemyFighters[0].Forward;
|
|
}
|
|
else
|
|
{
|
|
if (TeamFighters.Count == 0)
|
|
return Vector3.forward;
|
|
return TeamFighters[0].Ctrl != null ? TeamFighters[0].Ctrl.transform.forward : TeamFighters[0].Forward;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
public FighterManager(BaseBattle battle)
|
|
{
|
|
mBattle = battle;
|
|
IsDisposed = false;
|
|
}
|
|
|
|
FighterManager()
|
|
{
|
|
HasInitializedFighters = false;
|
|
}
|
|
|
|
public void SetPveMark()
|
|
{
|
|
for (int idx = 0; idx < mAllFighters.Count; idx++)
|
|
{
|
|
Fighter f = mAllFighters[idx];
|
|
if (f.IsTeamMember)
|
|
{
|
|
f.AddPveMark();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public void InitializeCurrentSceneFighters()
|
|
{
|
|
if (mBattle == null || HasInitializedFighters)
|
|
return;
|
|
|
|
List<ActorData> fighterInfos = mBattle.MyFighters;
|
|
for (int i = 0; i < fighterInfos.Count; i++)
|
|
{
|
|
AddFighter(fighterInfos[i], eTeamType.Friend);
|
|
}
|
|
|
|
fighterInfos = mBattle.EnemyFighters;
|
|
for (int i = 0; i < fighterInfos.Count; i++)
|
|
{
|
|
AddFighter(fighterInfos[i], eTeamType.Enemy);
|
|
}
|
|
|
|
|
|
//初始化召唤物
|
|
for (int idx = 0; idx < mAllFighters.Count; idx++)
|
|
{
|
|
Fighter f = mAllFighters[idx];
|
|
if (f.Skills == null || f.Skills.Length == 0) continue;
|
|
|
|
if (f.RageCloneBossId > 0)
|
|
{
|
|
ActorData ad = ActorData.CreateNpcPlayerActor(CommonUtil.CalcSummonNpcUniqueId(100, idx), f.RageCloneBossId, 1);
|
|
ad.PositionValue = f.PositionValue;
|
|
|
|
f.RageCloneBoss = Fighter.CreateFighter(this, ad, f.TeamSide, f);
|
|
mAllFighters.Add(f.RageCloneBoss);
|
|
}
|
|
|
|
for (int jdx = 0; jdx < f.Skills.Length; jdx++)
|
|
{
|
|
BaseSkill skill = f.Skills[jdx];
|
|
if (skill != null && skill.IsValid && (skill.SummonActors != null || skill.SummonBosses != null))
|
|
{
|
|
if (skill.SummonActors != null)
|
|
{
|
|
for (int i = 0; i < skill.SummonActors.Count; i++)
|
|
{
|
|
ValType sa = skill.SummonActors[i];
|
|
|
|
ActorData ad = ActorData.CreateNpcPlayerActor(CommonUtil.CalcSummonNpcUniqueId(100, idx), sa.id, 1);
|
|
ad.PositionValue = sa.val;
|
|
|
|
Fighter summon = Fighter.CreateFighter(this, ad, f.TeamSide, f);
|
|
mAllFighters.Add(summon);
|
|
skill.AddSummonActor(summon);
|
|
}
|
|
}
|
|
|
|
if (skill.SummonBosses != null)
|
|
{
|
|
for (int i = 0; i < skill.SummonBosses.Count; i++)
|
|
{
|
|
ValType sa = skill.SummonActors[i];
|
|
|
|
ActorData ad = ActorData.CreateNpcPlayerActor(CommonUtil.CalcSummonNpcUniqueId(100, idx), sa.id, 1);
|
|
ad.PositionValue = sa.val;
|
|
|
|
Fighter summon = Fighter.CreateFighter(this, ad, f.TeamSide, f);
|
|
mAllFighters.Add(summon);
|
|
skill.AddSummonActor(summon);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
HasInitializedFighters = true;
|
|
}
|
|
|
|
public void InitFighters()
|
|
{
|
|
if (mBattle == null || HasInitializedFighters)
|
|
return;
|
|
|
|
if (mBattle.TeamActors != null)
|
|
{
|
|
for (int idx = 0; idx < mBattle.TeamActors.Count; idx++)
|
|
{
|
|
AddFighter(mBattle.TeamActors[idx], eTeamType.Friend);
|
|
}
|
|
}
|
|
|
|
if (mBattle.EnemyActors != null)
|
|
{
|
|
for (int idx = 0; idx < mBattle.EnemyActors.Count; idx++)
|
|
{
|
|
AddFighter(mBattle.EnemyActors[idx], eTeamType.Enemy);
|
|
}
|
|
}
|
|
|
|
//初始化召唤物
|
|
for (int idx = 0; idx < mAllFighters.Count; idx++)
|
|
{
|
|
Fighter f = mAllFighters[idx];
|
|
if (f.Skills == null || f.Skills.Length == 0) continue;
|
|
|
|
if (f.RageCloneBossId > 0)
|
|
{
|
|
ActorData ad = ActorData.CreateNpcPlayerActor(CommonUtil.CalcSummonNpcUniqueId(100, idx), f.RageCloneBossId, 1);
|
|
ad.PositionValue = f.PositionValue;
|
|
|
|
f.RageCloneBoss = Fighter.CreateFighter(this, ad, f.TeamSide, f);
|
|
mAllFighters.Add(f.RageCloneBoss);
|
|
}
|
|
|
|
for (int jdx = 0; jdx < f.Skills.Length; jdx++)
|
|
{
|
|
BaseSkill skill = f.Skills[jdx];
|
|
if (skill != null && skill.IsValid && (skill.SummonActors != null || skill.SummonBosses != null))
|
|
{
|
|
if (skill.SummonActors != null)
|
|
{
|
|
for (int i = 0; i < skill.SummonActors.Count; i++)
|
|
{
|
|
ValType sa = skill.SummonActors[i];
|
|
ActorData ad = ActorData.CreateNpcPlayerActor(CommonUtil.CalcSummonNpcUniqueId(100, idx), sa.id, 1);
|
|
ad.PositionValue = sa.val;
|
|
|
|
Fighter summon = Fighter.CreateFighter(this, ad, f.TeamSide, f);
|
|
mAllFighters.Add(summon);
|
|
skill.AddSummonActor(summon);
|
|
}
|
|
}
|
|
|
|
if (skill.SummonBosses != null)
|
|
{
|
|
for (int i = 0; i < skill.SummonBosses.Count; i++)
|
|
{
|
|
ValType sa = skill.SummonBosses[i];
|
|
ActorData ad = ActorData.CreateNpcPlayerActor(CommonUtil.CalcSummonNpcUniqueId(100, idx), sa.id, 1);
|
|
ad.PositionValue = sa.val;
|
|
|
|
Fighter summon = Fighter.CreateFighter(this, ad, f.TeamSide, f);
|
|
mAllFighters.Add(summon);
|
|
skill.AddSummonActor(summon);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
HasInitializedFighters = true;
|
|
}
|
|
|
|
public void ParseLoad()
|
|
{
|
|
for (int idx = 0; idx < mAllFighters.Count; idx++)
|
|
{
|
|
Fighter fighter = mAllFighters[idx];
|
|
fighter.Ctrl.ParseLoad();
|
|
}
|
|
}
|
|
|
|
public Fighter AddFighter(ActorData actor, eTeamType side)
|
|
{
|
|
Fighter fighter = GetFighterByID(actor.ID, side);
|
|
if (fighter != null) return fighter;
|
|
|
|
|
|
fighter = Fighter.CreateFighter(this, actor, side);
|
|
if (fighter.IsTeamMember)
|
|
{
|
|
mTeamFigters.Add(fighter);
|
|
if (fighter.IsPet)
|
|
{
|
|
mTeamPetFighters.Add(fighter);
|
|
}
|
|
else
|
|
{
|
|
mTeamHeroFighters.Add(fighter);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mEnemyFighters.Add(fighter);
|
|
}
|
|
mAllFighters.Add(fighter);
|
|
|
|
return fighter;
|
|
}
|
|
|
|
public void AddFighters(ActorData[] actors, eTeamType side)
|
|
{
|
|
for (int i = 0; i < actors.Length; i++)
|
|
{
|
|
AddFighter(actors[i], side);
|
|
}
|
|
}
|
|
|
|
public Fighter GetMainRole()
|
|
{
|
|
return mTeamFigters.Find((o) => o.IsMainRole);
|
|
}
|
|
|
|
public void CacheTeamFighters()
|
|
{
|
|
mCacheTeamFighters.Clear();
|
|
mCacheTeamFighters.AddRange(mTeamFigters);
|
|
for (int idx = 0; idx < mCacheTeamFighters.Count; idx++)
|
|
{
|
|
RemoveFighter(mCacheTeamFighters[idx]);
|
|
}
|
|
}
|
|
|
|
public void RestoreTeamFighters()
|
|
{
|
|
for (int idx = mTeamFigters.Count - 1; idx >= 0; idx--)
|
|
{
|
|
Fighter f = mTeamFigters[idx];
|
|
RemoveFighter(f);
|
|
f.Destroy();
|
|
}
|
|
|
|
for (int idx = 0; idx < mCacheTeamFighters.Count; idx++)
|
|
{
|
|
AddTeamFighter(mCacheTeamFighters[idx]);
|
|
}
|
|
mCacheTeamFighters.Clear();
|
|
}
|
|
|
|
private void AddTeamFighter(Fighter f)
|
|
{
|
|
if (!mTeamFigters.Contains(f))
|
|
mTeamFigters.Add(f);
|
|
|
|
if (!mAllFighters.Contains(f))
|
|
mAllFighters.Add(f);
|
|
|
|
if (f.IsPet)
|
|
{
|
|
if (!mTeamPetFighters.Contains(f))
|
|
mTeamPetFighters.Add(f);
|
|
}
|
|
else
|
|
{
|
|
if (!mTeamHeroFighters.Contains(f))
|
|
mTeamHeroFighters.Add(f);
|
|
}
|
|
}
|
|
|
|
public void FixedUpdate(float deltaTime)
|
|
{
|
|
#if PROFILE
|
|
UnityEngine.Profiling.Profiler.BeginSample("FighterManager FixedUpdate1111");
|
|
#endif
|
|
for (int i = 0; i < mBattleFieldFighters.Count; i++)
|
|
{
|
|
Fighter fighter = mBattleFieldFighters[i];
|
|
if (fighter.IsSpawned && !fighter.IsDisposed && !fighter.IsDisposed)
|
|
{
|
|
fighter.FixedUpdate(deltaTime);
|
|
}
|
|
}
|
|
#if PROFILE
|
|
UnityEngine.Profiling.Profiler.EndSample();
|
|
#endif
|
|
|
|
#if PROFILE
|
|
UnityEngine.Profiling.Profiler.BeginSample("FighterManager FixedUpdate222222");
|
|
#endif
|
|
if (mBattle.IsFighting)
|
|
{
|
|
for (int i = 0; i < mBattleFieldFighters.Count; i++)
|
|
{
|
|
Fighter fighter = mBattleFieldFighters[i];
|
|
if (fighter.IsSpawned &&
|
|
!fighter.IsDisposed &&
|
|
fighter.IsAlive &&
|
|
fighter.AIEnable &&
|
|
!fighter.Actor.IsDisposed)
|
|
{
|
|
fighter.AI.Update(deltaTime);
|
|
}
|
|
}
|
|
}
|
|
#if PROFILE
|
|
UnityEngine.Profiling.Profiler.EndSample();
|
|
#endif
|
|
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
public void FixedUpdateByEditor(float deltaTime)
|
|
{
|
|
for (int i = 0; i < mAllFighters.Count; i++)
|
|
{
|
|
Fighter fighter = mAllFighters[i];
|
|
if (fighter.IsSpawned && !fighter.IsDisposed)
|
|
{
|
|
fighter.FixedUpdate(deltaTime);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < mAllFighters.Count; i++)
|
|
{
|
|
Fighter fighter = mAllFighters[i];
|
|
if (fighter.IsSpawned &&
|
|
!fighter.IsDisposed &&
|
|
fighter.IsAlive &&
|
|
fighter.AIEnable &&
|
|
!fighter.Actor.IsDisposed)
|
|
{
|
|
fighter.AI.Update(deltaTime);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
public void Dispose()
|
|
{
|
|
if (IsDisposed)
|
|
return;
|
|
|
|
try
|
|
{
|
|
for (int i = 0; i < mAllFighters.Count; i++)
|
|
{
|
|
var fighter = mAllFighters[i];
|
|
if (fighter != null)
|
|
{
|
|
fighter.Destroy();
|
|
}
|
|
}
|
|
|
|
RemoveAllFighters();
|
|
|
|
LeftCaptain = null;
|
|
RightCaptain = null;
|
|
|
|
HasInitializedFighters = false;
|
|
|
|
mBattle = null;
|
|
}
|
|
catch (System.Exception e)
|
|
{
|
|
DebugHelper.Log("error: {0}: {1}", e.Message, e.StackTrace);
|
|
}
|
|
|
|
IsDisposed = true;
|
|
}
|
|
|
|
public void OnFighterSpawned(Fighter fighter)
|
|
{
|
|
}
|
|
|
|
public void OnFighterDie(Fighter fighter)
|
|
{
|
|
Debug.Log("tzy_角色死亡_1");
|
|
if (mBattle.IsNormalBattle) Debug.Log("tzy_角色死亡_2 " + fighter);
|
|
if (mBattle.IsNormalBattle && fighter.IsNpc) Debug.Log("tzy_角色死亡_3 ");
|
|
if (mBattle.IsNormalBattle && fighter.IsNpc)
|
|
{
|
|
Vector3 startpos, goldpos, emptypos;
|
|
|
|
startpos = fighter.Ctrl.GetUIPointPos();
|
|
startpos += fighter.Actor.AvatarData.bloodBarPos;
|
|
startpos = Camera.main.WorldToViewportPoint(startpos);
|
|
Vector3 startpos2 = new Vector3(
|
|
(startpos.x - 0.5f) * UIMgr.SCREEN_WIDTH,
|
|
(startpos.y - 0.5f) * UIMgr.SCREEN_HEIGHT,
|
|
0
|
|
);
|
|
|
|
Debug.Log("tzy_ " + startpos2);
|
|
|
|
goldpos = new Vector3(421, -241, 0);
|
|
emptypos = new Vector3(0, 0, 0);
|
|
BattleDropMgr.Instance.GenerateDropItems(startpos2, true, goldpos, false, emptypos, false, emptypos, false, emptypos
|
|
, null, 0.05f, 0.25f);
|
|
}
|
|
}
|
|
|
|
public void OnFighterRelive(Fighter fighter)
|
|
{
|
|
}
|
|
|
|
public List<Fighter> GetUnSpawnedFighters(int wave)
|
|
{
|
|
return mAllFighters.FindAll(a => !a.IsSpawned && a.TeamSide == eTeamType.Enemy);
|
|
}
|
|
|
|
public List<Fighter> GetAllLeftSortedFighters()
|
|
{
|
|
List<Fighter> result = mAllFighters.FindAll(a => a.TeamSide == eTeamType.Friend);
|
|
CommonUtil.SortList(result, (lhs, rhs) => rhs.PositionValue - lhs.PositionValue);
|
|
return result;
|
|
}
|
|
|
|
public Fighter GetFighterByID(long id, eTeamType teamid, int idx = 0)
|
|
{
|
|
for (int i = 0; i < mAllFighters.Count; i++)
|
|
{
|
|
if (mAllFighters[i].TeamSide == teamid && mAllFighters[i].Id == id)
|
|
{
|
|
return mAllFighters[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public Fighter GetFighterByBaseId(int baseId, eTeamType teamId)
|
|
{
|
|
for (int idx = 0; idx < mAllFighters.Count; idx++)
|
|
{
|
|
if (mAllFighters[idx].TeamSide == teamId && mAllFighters[idx].Actor.BaseId == baseId)
|
|
{
|
|
return mAllFighters[idx];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public Fighter GetFighterByInstanceID(ulong instanceid)
|
|
{
|
|
for (int i = 0; i < mAllFighters.Count; i++)
|
|
{
|
|
if (mAllFighters[i].InstanceId == instanceid)
|
|
return mAllFighters[i];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public Fighter GetTeamMemberById(long id)
|
|
{
|
|
for (int idx = 0; idx < mTeamFigters.Count; idx++)
|
|
{
|
|
if (mTeamFigters[idx].Id == id)
|
|
return mTeamFigters[idx];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public Fighter GetNpcByBaseId(int baseId)
|
|
{
|
|
for (int idx = 0; idx < mAllFighters.Count; idx++)
|
|
{
|
|
Fighter fighter = mAllFighters[idx];
|
|
if (fighter.Actor.IsNpc && fighter.Actor.BaseId == baseId)
|
|
{
|
|
return fighter;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void AddFighterToBattleField(Fighter fighter)
|
|
{
|
|
if (mBattleFieldFighters.Contains(fighter)) return;
|
|
|
|
mBattleFieldFighters.Add(fighter);
|
|
}
|
|
|
|
public void RemoveFighterFromBattleField(Fighter fighter)
|
|
{
|
|
mBattleFieldFighters.Remove(fighter);
|
|
}
|
|
|
|
public void RemoveFighter(Fighter fighter)
|
|
{
|
|
mAllFighters.Remove(fighter);
|
|
mTeamFigters.Remove(fighter);
|
|
mTeamPetFighters.Remove(fighter);
|
|
mTeamHeroFighters.Remove(fighter);
|
|
mBattleFieldFighters.Remove(fighter);
|
|
mEnemyFighters.Remove(fighter);
|
|
}
|
|
|
|
public void RemoveAllFighters()
|
|
{
|
|
mAllFighters.Clear();
|
|
mTeamFigters.Clear();
|
|
mBattleFieldFighters.Clear();
|
|
mEnemyFighters.Clear();
|
|
mTeamPetFighters.Clear();
|
|
mTeamHeroFighters.Clear();
|
|
}
|
|
|
|
public bool HasTeamHero(long id)
|
|
{
|
|
for (int idx = 0; idx < mTeamHeroFighters.Count; idx++)
|
|
{
|
|
if (mTeamHeroFighters[idx].Id == id) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool HasPet(long id)
|
|
{
|
|
for (int idx = 0; idx < mTeamPetFighters.Count; idx++)
|
|
{
|
|
if (mTeamPetFighters[idx].Id == id) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
public bool HasTeamMember(long id)
|
|
{
|
|
for (int idx = 0; idx < mTeamFigters.Count; idx++)
|
|
{
|
|
if (mTeamFigters[idx].Id == id) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
List<Fighter> tempList = new List<Fighter>();
|
|
public void SortTeamFighters()
|
|
{
|
|
int tempCount = 0;
|
|
for (int idx = (int)ProfessionType.Pro_Type_0; idx <= (int)ProfessionType.Pro_Type_Priest; idx++)
|
|
{
|
|
tempList.Clear();
|
|
FindFightersByProfessionType(idx, ref tempList);
|
|
for (int jdx = 0; jdx < tempList.Count; jdx++)
|
|
{
|
|
tempList[jdx].ReadyPosOrder = jdx + 1;
|
|
}
|
|
tempCount += tempList.Count;
|
|
if (tempCount == TeamHeroFighters.Count) break;
|
|
}
|
|
|
|
tempList.Clear();
|
|
}
|
|
|
|
|
|
private void FindFightersByProfessionType(int proType, ref List<Fighter> list)
|
|
{
|
|
for (int idx = 0; idx < TeamHeroFighters.Count; idx++)
|
|
{
|
|
if (TeamHeroFighters[idx].Actor.Profession == (ProfessionType)proType)
|
|
{
|
|
list.Add(TeamHeroFighters[idx]);
|
|
}
|
|
}
|
|
}
|
|
}
|