public double GetMaxHp(int unitId, FormulaController formula)
{
if (BattleMode)
{
var member = _battleAccessor.GetMember(unitId);
return(member.HpMax.Value);
}
else
{
var unit = _unitAccessor.GetUnit(unitId);
return(_unitAccessor.CalculateMaxHp(unit.data, formula).Value);
}
}
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;
}
}
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 void StartExplorer(int stageId)
{
var stageData = _explorer.GetStage(stageId);
_explorer.SetCurrentStage(stageId);
_explorer.State.PlayerBuffs.Clear();
foreach (var id in stageData.ObjectAvailibility.Select(x => x.Key).ToList())
{
var staticData = _explorer.Static.Objects[id];
if (staticData.Revert)
{
stageData.ObjectAvailibility.Remove(id);
}
}
_scorersLogic.ClearTemporaryScorers();
var maxStamina = 0;
foreach (var unitId in _units.ExplorerUnits)
{
var(data, def) = _units.GetUnit(unitId);
maxStamina += _units.CalculateMaxStamina(unitId);
foreach (var perk in data.PerkStars)
{
var charges = _units.CalculatePerkCharges(unitId, perk.Key);
data.PerkCharges[perk.Key] = charges;
}
//_context.SetContextFormula(unitId);
//data.CurrentHp = (float)_units.CalculateMaxHp(data, _formula).Value;
}
foreach (var data in _units.State.Units)
{
if (data.Stars > 0)
{
_context.SetContextFormula(data.Id);
data.CurrentHp = (float)_units.CalculateMaxHp(data, _formula).Value;
}
}
_context.SetContextFormula(null);
stageData.Values[_scorers.StaminaId] = maxStamina;
}
public IMemberBattleData CreateBattleUnit(IUnitData unit, bool assist)
{
_context.NeedExploreParam = true;
_context.SetContextFormula(unit.Id);
var data = _battle.Factory.CreateBattleMember(
unit.Id,
unit.ExplorerPosition,
_units.CalculateMaxHp(unit, _formula),
_units.CalculateStrength(unit, _formula),
_units.CalculateInitiative(unit, _formula),
BattleMemberType.Unit
);
_context.SetContextFormula(null);
_context.NeedExploreParam = false;
data.Assist = assist;
data.CurrentHp = unit.CurrentHp;
var abilities = _units.Static.Abilities.Values.Where(x => x.Params.UnitId == unit.Id).ToArray();
UpdateParams(data, abilities);
return(data);
}
public override void Execute(IImpactUnitAdd impactData)
{
if (impactData.Unit.Assist)
{
if (_units.State.Assist != null)
{
Logger.Error($"The helper has already been added. Existing unit id = {_units.State.Assist.Id}", this);
return;
}
if (_units.TryGetUnit(impactData.Unit.Id, false, out var find))
{
Logger.Error($"A helper cannot be added because such a unit is already in the state. id = {impactData.Unit.Id}", this);
return;
}
var unit = _units.CreateUnit(impactData.Unit);
//_impact.ExecuteImpact(_units.Units[unit.Id].ImpactInit);
unit.ExplorerPosition = HardCodeIds.BattleAssistSlot;
_units.State.Assist = unit;
if (_context.BattleMode)
{
var battleUnit = _logic.CreateBattleUnit(unit, true);
_battle.State.Data.Allies[unit.Id] = battleUnit;
battleUnit.CurrentHp = (float)battleUnit.HpMax.Value;
unit.CurrentHp = battleUnit.CurrentHp;
}
else
{
_context.SetContextFormula(unit.Id);
unit.CurrentHp = (int)_units.CalculateMaxHp(unit, _formula).Value;
_context.SetContextFormula(null);
}
}
else
{
//var addedCommand = _explorer.State.LastTeam.Count < 3;
if (!_units.AddUnit(impactData.Unit))
{
_units.AddUnitShard(impactData.Unit.Id, _settings.Settings.PlayerSettings.UnitDuplicateCost);
}
else
{
_impact.ExecuteImpact(_units.Units[impactData.Unit.Id].ImpactInit);
var data = _units.GetUnit(impactData.Unit.Id).data;
_context.SetContextFormula(data.Id);
data.CurrentHp = (int)_units.CalculateMaxHp(data, _formula).Value;
_context.SetContextFormula(null);
}
_units.UpdateLastTeamSlots();
//var free = _explorer.GetFreeSlot();
//if (impactData.Unit.SlotExplorer > 0 && !_units.State.LastTeam.Select(x => x.Value).Contains(impactData.Unit.SlotExplorer))
//{
// _units.State.LastTeam[impactData.Unit.Id] = impactData.Unit.SlotExplorer;
//}
//else if (free != null)
//{
// _units.State.LastTeam[impactData.Unit.Id] = free.Value;
//}
}
LogicLog.UnitAdd(impactData.Unit.Id, impactData.Unit.Assist);
}
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);
}
}
}