public override bool Check(IConditionScorer restictionData)
{
var currentCount = _scorers.GetScorer(restictionData.Scorer, restictionData.StageId);
var value = (int)_logic.Calculate(restictionData.Value);
return(restictionData.Operator.Check(currentCount, value));
}
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 override void Execute(IImpactUnitShard data)
{
var value = (int)_logic.Calculate(data.Shards);
_accessor.AddUnitShard(data.UnitId, value);
LogicLog.AddUnitShard(data.UnitId, value);
}
public override bool Check(IConditionAvailability restictionData)
{
_inventory.State.Items.TryGetValue(restictionData.ItemId, out var currentValue);
var value = (int)_logic.Calculate(restictionData.Value);
return(restictionData.Operator.Check(currentValue, value));
}
public override void Execute(IImpactRandomWeight data)
{
var dataWeight = new List <(int, IImpact)>();
foreach (var temp in data.Weights.Values)
{
if (!_condition.Check(temp.Impact.Condition))
{
continue;
}
dataWeight.Add(((int)_formulaLogic.Calculate(temp.Formula), temp.Impact));
}
if (dataWeight.Count == 0)
{
return;
}
if (dataWeight.Count == 1)
{
_impactLogic.ExecuteImpact(dataWeight.FirstOrDefault().Item2);
return;
}
var result = _settings.GetWeightRandom(dataWeight);
_impactLogic.ExecuteImpact(result.Item2, false);
}
public override bool Check(IConditionPlayerLevel restictionData)
{
var level = (int)_logic.Calculate(restictionData.Value);
var currentLevel = _player.State.Level;
return(restictionData.Operator.Check(currentLevel, level));
}
public override void Execute(IImpactChangeMana data)
{
//if (_battle.State.Data == null)
//{
// throw new Exception("ImpactManaExecutor Битва не запущена");
//}
var manaId = _scorers.ManaId;
var value = (int)_logic.Calculate(data.Value);
if (!_explorer.State.IsRun)
{
Logger.Error("Attempting to record mana for stage outside of explorer", this);
return;
}
var stage = _explorer.GetStage(_explorer.CurrentStage);
stage.Values.TryGetValue(manaId, out var scorer);
if (data.Oversize)
{
value = (int)scorer + value;
}
else
{
value = Mathf.Min((int)scorer + value, _settings.Settings.PlayerSettings.ManaMax);
value = Mathf.Max(value, 0);
}
stage.Values[manaId] = value;
}
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(IUnitConditionSlots restictionData)
{
var members = (restictionData.Target == TargetType.Owner && !_context.ContextTurn.IsEnemy ? _battle.LiveAllies : _battle.LiveEnemies);
var count = HardCodeIds.MaxBattleSlots - members.Count();
var value = (int)_formula.Calculate(restictionData.Value);
return(restictionData.Operator.Check(count, 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 override bool Check(IConditionRand data)
{
if (_data.IsEmulate)
{
return(false);
}
var value = _formula.Calculate(data.Value);
return(new Random().NextDouble() <= value / 100.0f);
}
public override void Execute(IImpactChangeStamina data)
{
if (!_explorer.State.IsRun)
{
throw new Exception("Explore not running");
}
var value = (int)_logic.Calculate(data.Value);
var staminaId = _scorers.StaminaId;
_explorer.SpendScorer(staminaId, -value);
}
//public FormulaLogic Logic { get;set; }
//[Query]
//public int Stamina => State.Values["stamina"];
//[Query]
//public IReadOnlyDictionary<int, IScorer> Scorers => Static.Scorers;
public void Spend(IPrice price, FormulaLogic logic)
{
var value = (int)logic.Calculate(price.Value);
var scorerId = Static.MoneyTypes[price.MoneyType].ScorerId;
State.Values.TryGetValue(scorerId, out var count);
if (count < value)
{
throw new Exception($"Недостаточно ресурсов type = {price.MoneyType} для покупки ({count} < {value})");
}
State.Values[scorerId] = count - value;
}
public override void Execute(IImpactScorerData data)
{
var value = (long)_logic.Calculate(data.Value);
var values = _scorers.GetScrorerMap(data.Id, data.StageId);
if (values == null)
{
return;
}
long delta = 0;
switch (data.Operator)
{
case OperationType.Add:
delta = value;
values[data.Id] += value;
break;
case OperationType.Set:
delta = value - values[data.Id];
values[data.Id] = value;
break;
default:
throw new ArgumentOutOfRangeException();
}
if (delta > 0)
{
var staticData = _scorers._scorers.Static.MoneyTypes.Values.FirstOrDefault(x => x.ScorerId == data.Id);
if (staticData != null && staticData.AchievScorerId != 0)
{
values = _scorers.GetScrorerMap(staticData.AchievScorerId, 0);
if (values != null)
{
values[staticData.AchievScorerId] += delta;
}
}
}
if (_scorers.HasLog(data.Id))
{
var logStage = data.StageId;
if (logStage == 0)
{
if (_explorer.State.IsRun)
{
logStage = _explorer.CurrentStage;
}
}
LogicLog.ChangeScorer(data.Id, data.Operator, value, logStage);
}
}
public override bool Check(IUnitConditionBuff data)
{
var membler = _contextLogic.CurrentTarget;
var count = 0;
if (membler.Buffs.TryGetValue(data.BuffId, out var buffData))
{
count = buffData.CountStack;
}
var value = (int)_formula.Calculate(data.Value);
return(data.Operator.Check(count, value));
}
public override void Execute(IUnitImpactAnimFrame data)
{
_logic.BatchAbilityInFrame();
var frameData = new FrameAbility {
FamiliarAnimStart = data.FamiliarAnimStart, UnityId = data.UnityObjectId
};
if (float.TryParse(data.ShellDuration, out var value))
{
frameData.ShellDuration = value;
}
frameData.Time = (float)_formula.Calculate(data.TimeFormula);
_logic.Data = frameData;
}
public override void Execute(IImpactChangeMoney data)
{
var value = (int)_logic.Calculate(data.Value);
var data1 = _scorers.Static.MoneyTypes[data.MoneyTypeId];
var id = _scorers.Static.MoneyTypes[data.MoneyTypeId].ScorerId;
var dict = _scorers.State.Values;
dict.TryGetValue(id, out var oldValue);
var delta = 0;
switch (data.Operator)
{
case OperationType.Add:
dict[id] = oldValue + value;
delta = value;
break;
case OperationType.Set:
delta = value - (int)oldValue;
dict[id] = value;
break;
default:
throw new ArgumentOutOfRangeException();
}
if (delta > 0)
{
if (data1.AchievScorerId != 0)
{
if (!dict.ContainsKey(data1.AchievScorerId))
{
dict[data1.AchievScorerId] = 0;
}
dict[data1.AchievScorerId] += delta;
}
}
if (dict[id] <= 0)
{
dict.Remove(id);
}
LogicLog.ChangeMoneyType(data.MoneyTypeId, data.Operator, value);
}
public override void Execute(IImpactChangePerkCharges data)
{
var value = (int)_logic.Calculate(data.Value);
var unitData = _units.ExplorerUnits
.Select(x => {
var(unit, _) = _units.GetUnit(x);
return(unit);
})
.FirstOrDefault(x => {
x.PerkCharges.TryGetValue(data.PerkId, out value);
return(value > 0);
});
if (unitData == null)
{
throw new Exception($"Закончились заряды перка");
}
unitData.PerkCharges[data.PerkId] -= 1;
LogicLog.ChangePerkCharge(data.PerkId, value);
}
public override void Execute(IImpactItemData data)
{
var value = (int)_logic.Calculate(data.Value);
ILogicDictionary <int, int> dict;
if (!data.IsExplorer)
{
if (!_inventory.State.Items.ContainsKey(data.ItemId))
{
_inventory.State.Items[data.ItemId] = 0;
}
dict = _inventory.State.Items;
}
else
{
if (!_explorer.State.Inventory.ContainsKey(data.ItemId))
{
_explorer.State.Inventory[data.ItemId] = 0;
}
dict = _explorer.State.Inventory;
}
switch (data.Operator)
{
case OperationType.Add:
dict[data.ItemId] += value;
break;
case OperationType.Set:
dict[data.ItemId] = value;
break;
default:
throw new ArgumentOutOfRangeException();
}
if (dict[data.ItemId] <= 0)
{
dict.Remove(data.ItemId);
}
LogicLog.ChangeItemValue(data.ItemId, value);
}
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 override double Calculate(IFormulaConst formulaData)
{
return(_logic.Calculate(_scorer.Static.Consts[formulaData.ConstId].Formula));
}
public override void Execute(IImpactBuff data)
{
_explorer.State.PlayerBuffs[data.BuffId] = (int)_logic.Calculate(data.Value);
}
public Double Calculate(IFormula data, Int32 unit)
{
return(FormulaLogic.Calculate(data, unit));
}
public override void Execute(IImpactPlayerExp data)
{
var exp = (int)_formula.Calculate(data.Value);
_accessor.UpgradeLevel(exp);
}
