public bool HasExecuteAbility(int id, int abilityId)
{
var data = _battle.GetMember(id);
var staticData = _units.Static.Abilities[abilityId];
if (!_condition.CheckUnit(staticData.Actable, id))
{
return(false);
}
//if (staticData.Params.Mode != AbilityType.Passive && data.CurrentHp <= 0)
//{
// return false;
//}
var abilityData = data.Abilities[abilityId];
if (staticData.LimitTurn > 0)
{
if (abilityData.CountTurn >= staticData.LimitTurn)
{
return(false);
}
}
if (staticData.LimitBattle > 0)
{
if (abilityData.CountBattle >= staticData.LimitBattle)
{
return(false);
}
}
return(true);
}
public List <int> UpdateBuff()
{
var list = new List <int>();
var data = _accessor.GetMember(_contextLogic.ContextTurn.OwnerId);
foreach (var temp in data.Buffs.Select(x => x.Key).ToArray())
{
var buffState = data.Buffs[temp];
var staticData = _accessor.Static.Buffs[temp];
if (buffState.NeededRemove)
{
buffState.NeededRemove = false;
continue;
}
var targetData = _accessor.GetMember(buffState.OwnerId);
if (targetData != null && targetData.Status == UnitBattleStatus.DeadInTern)
{
buffState.CountStack -= staticData.WithdrawDeath;
}
if (buffState.CountStack <= staticData.WithdrawTurn)
{
data.Buffs.Remove(temp);
list.Add(temp);
}
else
{
buffState.CountStack -= staticData.WithdrawTurn;
}
}
_logic.BatchBattle();
return(list);
}
public IMemberBattleData GetMember(TargetType restictionDataTarget)
{
switch (restictionDataTarget)
{
case TargetType.Owner:
return(_battleAccessor.GetMember(CurrentContext.OwnerId));
case TargetType.Target:
return(_battleAccessor.GetMember(CurrentContext.CurrentTarget));
default:
throw new ArgumentOutOfRangeException(nameof(restictionDataTarget), restictionDataTarget, null);
}
}
public override void Execute(IUnitImpactBuff data)
{
var contextImpact = _context.ContextImpact;
var value = (int)_logic.Calculate(data.Value);
var member = _battle.GetMember(_context.ContextImpact.CurrentTarget);
if (!member.Buffs.TryGetValue(data.BuffId, out var buffData))
{
if (value < 0)
{
return;
}
var buff = _battle.Static.Buffs[data.BuffId];
_impact.ExecuteImpact(buff.ImpactInit);
buffData = _battle.Factory.CreateBuff(contextImpact.OwnerId, false);
if (contextImpact.OwnerId == contextImpact.CurrentTarget &&
(_context.TurnType == BattleTurnResultType.ActiveAbility || _context.TurnType == BattleTurnResultType.StartTurn))
{
buffData.NeededRemove = true;
}
_buffs.ChangeBuff(member, buffData, data.BuffId, value);
member.Buffs[data.BuffId] = buffData;
}
else
{
if (!_buffs.ChangeBuff(member, buffData, data.BuffId, value))
{
_impact.ExecuteImpact(_battle.Static.Buffs[data.BuffId].ImpactTakeOff);
}
}
}
public bool CheckTrigger(TriggerUnitData context, ITriggerHp data)
{
var state = _accessor.GetMember(context.TargetId);
var value = _formula.Calculate(data.Value) / 100.0f;
var currentProcent = state.CurrentHp / state.HpMax.Value;
return(data.Operator.Check(currentProcent, value));
}
public override bool Check(IUnitConditionBuffType data)
{
var membler = _battle.GetMember(_context.ContextImpact.CurrentTarget);
var count = membler.Buffs.Count(x => _battle.Static.Buffs[x.Key].BuffType.Values.Contains(data.BuffTypeId));
var value = (int)_formula.Calculate(data.Value);
return(data.Operator.Check(count, value));
}
public override bool Check(IUnitConditionMostHp restictionData)
{
if (_logic.BattleMode)
{
var list = new List <int>();
if (_logic.ConditionTarget != null)
{
list = _logic.FindContextTarget(_logic.ConditionTarget.Value, _logic.ContextImpact);
}
else
{
list = _battle.LiveAllies.ToList();
list.AddRange(_battle.LiveEnemies.ToList());
}
list = list.OrderByDescending(x => _battle.GetMember(x).CurrentHp / _battle.GetMember(x).HpMax.Value).ToList();
switch (restictionData.HpType)
{
case HpType.Healthy:
return(list.First() == _logic.ContextCondition.CurrentTarget);
case HpType.Wounded:
return(list.Last() == _logic.ContextCondition.CurrentTarget);
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
var members = _units.ExplorerUnits.Select(x => _units.GetUnit(x).data);
members = members.OrderByDescending(x => x.CurrentHp / _units.CalculateMaxHp(x, _formula).Value).ToList();
switch (restictionData.HpType)
{
case HpType.Healthy:
return(members.First().Id == _logic.ContextCondition.CurrentTarget);
case HpType.Wounded:
return(members.Last().Id == _logic.ContextCondition.CurrentTarget);
default:
throw new ArgumentOutOfRangeException();
}
}
}
public bool CheckTrigger(TriggerUnitData triggerData, ITriggerBuff data)
{
var member = _battle.GetMember(triggerData.TargetId);
var all = member.TurnBuffs.Count(x => x == data.BuffId);
var value = _formula.Calculate(data.Value);
var result = data.Operator.Check(all, value);
member.TurnBuffs.Clear();
return(result);
}
public bool CheckTrigger(TriggerUnitData triggerData, ITriggerFamiliarSummon data)
{
var member = _battle.GetMember(triggerData.TargetId);
var result = member.TurnFamiliarSummoned;
if (result)
{
member.TurnFamiliarSummoned = false;
}
return(result);
}
public override bool Check(IUnitConditionMob restictionData)
{
if (!_context.BattleMode)
{
throw new Exception($"It is impossible to check the presence of a mob not in combat. mobId = {restictionData.MobId}");
}
var member = _battle.GetMember(_context.ContextCondition.CurrentTarget);
if (member == null)
{
return(true);
}
var haveUnit = member.StaticId == restictionData.MobId;
return(haveUnit);
}
public override void Execute(IUnitImpactExp impactData)
{
int currentTarget = _context.ContextImpact.CurrentTarget;
if (_context.BattleMode)
{
if (_context.ContextImpact.IsEnemy)
{
Logger.Error($"The enemy cannot receive exp target = {_context.ContextImpact.CurrentTarget}", this);
return;
}
}
var(data, unit) = _units.GetUnit(currentTarget);
var oldLevel = data.Level;
var exp = (int)_formula.Calculate(impactData.Value);
if (exp < 1)
{
return;
}
var newLevel = _units.UpgradeUnitLevel(data.Id, exp, _player.State.Level);
var updateLevel = oldLevel != newLevel;
while (oldLevel != newLevel)
{
oldLevel++;
var levelData = _units.Static.UnitLevels.Values.FirstOrDefault(x => x.Level == oldLevel);
_logic.ExecuteImpact(levelData?.Impact);
_logic.ExecuteImpact(unit.ImpactUpdrade);
}
if (updateLevel && _context.BattleMode)
{
_context.SetContextFormula(unit.Id);
_context.NeedExploreParam = true;
var member = _battle.GetMember(currentTarget);
member.HpMax = _units.CalculateMaxHp(data, _formula);
member.Strength = _units.CalculateStrength(data, _formula);
member.Initiative = _units.CalculateInitiative(data, _formula);
_context.SetContextFormula(null);
_context.NeedExploreParam = false;
}
}
private void UpdateBuffs(bool isEnemy)
{
var owner = _battle.GetMember(_contextLogic.ContextTurn.OwnerId);
foreach (var temp in owner.Buffs)
{
var buffStatic = _battle.Static.Buffs[temp.Key];
if (buffStatic.Impact != null)
{
_contextLogic.SetContextImpact(temp.Value.OwnerId, _contextLogic.ContextTurn.OwnerId, isEnemy);
_impactLogic.ExecuteImpact(buffStatic.Impact);
}
}
var list = _buffLogic.UpdateBuff();
foreach (var temp in list)
{
_impactLogic.ExecuteImpact(_battle.Static.Buffs[temp].ImpactTakeOff);
}
}
public override void Execute(IUnitImpactLeave data)
{
if (_context.BattleMode)
{
var targetId = _context.ContextImpact.CurrentTarget;
var member = _battle.GetMember(targetId);
if (member == null)
{
Logger.Error($"No member in battle CurrentTarget = {targetId} ", this);
return;
}
member.Status = UnitBattleStatus.Leave;
member.CurrentHp = 0;
member.Status = UnitBattleStatus.DeadInTernNoDropped;
}
else
{
Logger.Error($"No leave unit in no battle", this);
}
}
public override void Execute(IUnitImpactBuffType data)
{
var targetId = _context.ContextImpact.CurrentTarget;
var member = _battle.GetMember(targetId);
if (member == null)
{
Logger.Error($"No member in battle CurrentTarget = {targetId} ", this);
return;
}
var buffs = member.Buffs
//.Where(x => _battle.Static.Buffs[x.Key].BuffType.Values.Contains(data.BuffTypeId))
.Select(x => x.Key).ToArray();
var value = (int)_logic.Calculate(data.Value);
foreach (var id in buffs)
{
var buffTypeValues = _battle.Static.Buffs[id].BuffType.Values;
var contains = false;
foreach (var buffType in buffTypeValues)
{
if (data.BuffTypeIds.Values.Contains(buffType))
{
contains = true;
break;
}
}
if (contains)
{
if (!_buffs.ChangeBuff(member, member.Buffs[id], id, value))
{
_impacts.ExecuteImpact(_battle.Static.Buffs[id].ImpactTakeOff);
}
}
}
}
public bool CheckTrigger(TriggerUnitData context, ITriggerInfluence data)
{
var state = _accessor.GetMember(context.TargetId);
return(state.TurnInfluence.Remove(data.InfluenceType));
}
public override void Execute(IUnitImpactHp data)
{
var targetId = _context.ContextImpact.CurrentTarget;
var value = (float)_logic.Calculate(data.Value);
if (_context.BattleMode)
{
var member = _battle.GetMember(targetId);
if (member == null)
{
Logger.Error($"No member in battle CurrentTarget = {targetId} ", this);
return;
}
var oldHp = member.CurrentHp;
if (value < 0)
{
value = Mathf.Min(value, member.CurrentHp);
member.CurrentHp = member.CurrentHp + value;
if (member.CurrentHp <= 0)
{
member.Status = UnitBattleStatus.DeadInTernNoDropped;
if (member.MemberType == BattleMemberType.Unit)
{
_units.SetUnitReserve(member.StaticId, true);
}
}
}
else
{
value = Mathf.Min(value, (float)member.HpMax.Value - member.CurrentHp);
member.CurrentHp = member.CurrentHp + value;
}
if (_units.Static.Abilities.TryGetValue(_context.CurrentAbility, out var ability))
{
if (member.CurrentHp < oldHp)
{
if (ability.Influence.Values.Contains(InfluenceType.Attack))
{
member.TurnInfluence.Add(InfluenceTargetType.Attack);
}
if (ability.Influence.Values.Contains(InfluenceType.AttackDistance))
{
member.TurnInfluence.Add(InfluenceTargetType.AttackDistance);
}
}
if (member.CurrentHp > oldHp)
{
if (ability.Influence.Values.Contains(InfluenceType.Attack))
{
member.TurnInfluence.Add(InfluenceTargetType.Heal);
}
}
}
}
else
{
var(member, unit) = _units.GetUnit(targetId);
var max = _units.CalculateMaxHp(member, _logic);
if (value < 0)
{
value = Mathf.Min(value, member.CurrentHp);
member.CurrentHp = member.CurrentHp + value;
if (member.CurrentHp <= 0)
{
_units.SetUnitReserve(targetId, true);
}
}
else
{
member.CurrentHp = Mathf.Min(member.CurrentHp + value, (float)max.Value);
}
}
}
