public bool IsTarget(TriggerUnitData data, TargetActivationType target)
{
switch (target)
{
case TargetActivationType.Owner:
if (data.OwnerId != data.TargetId)
{
return(false);
}
break;
case TargetActivationType.Ally:
if (LiveEnemies.Contains(data.TargetId) && !LiveAllies.Contains(data.OwnerId))
{
return(false);
}
break;
case TargetActivationType.Enemy:
if (LiveEnemies.Contains(data.TargetId) && LiveAllies.Contains(data.OwnerId))
{
return(false);
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(target), target, null);
}
return(true);
}
public bool CheckTrigger(TriggerUnitData data, IActivationEvent activation, ActivationType type)
{
if (activation.Type == TriggerType.TriggerManual)
{
return(false);
}
if (type == ActivationType.StartBattle)
{
return(activation.Type == TriggerType.TriggerStartBattle);
}
if (activation.Events == null)
{
return(false);
}
if (!_battle.IsTarget(data, activation.Target))
{
return(false);
}
foreach (var temp in activation.Events)
{
if (!_triggers.TryGetValue(temp.Value.Activation.Type, out Func <TriggerUnitData, ITrigger, bool> action))
{
throw new Exception($"no register impact executor type = {temp.Value.Activation.Type}");
}
if (action.Invoke(data, temp.Value.Activation))
{
return(true);
}
}
return(false);
}
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 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);
}
private void ExecuteStartAbility(int unit, bool isEnemy)
{
var data = new TriggerUnitData {
OwnerId = unit, TargetId = unit
};
foreach (var temp in _battleLogic.GetAbilities(unit))
{
if (!_triggerLogic.CheckTrigger(data, temp.Activation, ActivationType.StartBattle))
{
continue;
}
if (!_battleLogic.HasExecuteAbility(data.TargetId, temp.Id))
{
continue;
}
Logger.Trace(() => $"----------------------------------- start execute impact passive ability memberId = {data.TargetId} abilityId = {temp.Id}");
ExecuteAbility(data.OwnerId, null, temp.Impact, temp.Id, isEnemy);
Logger.Trace(() => $"----------------------------------- finish execute impact ability");
}
}
private void ExecutePassiveAbility(ActivationType eventTrigger, bool isOnlyEnemies = false)
{
bool isExecuteAblility = true;
HashSet <int> lastUnitIds = new HashSet <int>();
//var ownerId = _contextLogic.ContextTurn?.OwnerId ?? -1;
while (isExecuteAblility)
{
isExecuteAblility = false;
UpdatePassiveAbilities();
void UpdatePassiveAbilities()
{
var updateAllies = new List <int>(_battle.LiveAllies);
updateAllies.RemoveAll(x => lastUnitIds.Contains(x));
var updateEnemies = new List <int>(_battle.State.Data.Enemies.Where(x => x.Value.Status != UnitBattleStatus.Dead).Select(x => x.Key));
updateEnemies.RemoveAll(x => lastUnitIds.Contains(x));
lastUnitIds.Clear();
foreach (var id in updateEnemies)
{
if (lastUnitIds.Contains(id))
{
continue;
}
var data = new TriggerUnitData {
OwnerId = id, TargetId = id
};
UpdateAbilities(data, _battleLogic.GetAbilities(id), true);
}
if (!isOnlyEnemies)
{
foreach (var unit in updateAllies)
{
if (lastUnitIds.Contains(unit))
{
continue;
}
var data = new TriggerUnitData {
OwnerId = unit, TargetId = unit
};
UpdateAbilities(data, _battleLogic.GetAbilities(unit), false);
}
}
}
void UpdateAbilities(TriggerUnitData data, IEnumerable <IAbility> abilities, bool isEnemy)
{
foreach (var temp in abilities)
{
if (_triggerLogic.CheckTrigger(data, temp.Activation, eventTrigger))
{
if (_battleLogic.HasExecuteAbility(data.TargetId, temp.Id))
{
Logger.Trace(() => $"----------------------------------- start execute impact passive ability memberId = {data.TargetId} abilityId = {temp.Id}");
ExecuteAbility(data.OwnerId, null, temp.Impact, temp.Id, isEnemy);
Logger.Trace(() => $"----------------------------------- finish execute impact ability");
isExecuteAblility = eventTrigger != ActivationType.StartBattle;
lastUnitIds.Add(data.OwnerId);
}
}
}
}
}
}
public bool CheckTrigger(TriggerUnitData context, ITriggerInfluence data)
{
var state = _accessor.GetMember(context.TargetId);
return(state.TurnInfluence.Remove(data.InfluenceType));
}
