public float GetCurrentHp(int unitId)
{
if (BattleMode)
{
var member = _battleAccessor.GetMember(unitId);
return(member.CurrentHp);
}
else
{
var unit = _unitAccessor.GetUnit(unitId);
return(unit.data.CurrentHp);
}
}
public override bool Check(IUnitConditionHave data)
{
var value = (int)_formula.Calculate(data.RarityValue);
if (_context.BattleMode)
{
if (_context.ContextCondition.CurrentTarget != data.UnitId)
{
return(false);
}
var haveUnit = _battle.LiveAllies.Contains(data.UnitId);
if (!haveUnit)
{
return(false);
}
return(data.Operator.Check(_units.GetUnit(data.UnitId).data.Stars, value));
}
if (!_units.TryGetUnit(data.UnitId, false, out var unitData))
{
return(false);
}
if (_context.ContextCondition != null && _context.ContextCondition.CurrentTarget > 0 && _context.ContextCondition.CurrentTarget != data.UnitId)
{
return(false);
}
return(data.Operator.Check(unitData.Stars, value));
}
public void SetUnitEquipment(int unitId, int slot)
{
var(data, defUnit) = _units.GetUnit(unitId);
var currentEquipment = defUnit.Equipment.Values.FirstOrDefault(x => x.Slot == slot && x.Stars == data.EquipmentStars);
if (currentEquipment == null)
{
throw new Exception($"Unit id ={unitId} no equipment id = {slot}");
}
if (!_resources.HasItem(currentEquipment.ItemId))
{
throw new Exception($"Unable to insert equipment for a unit. no required item in inventory. unit id = {unitId} slot = {slot} item_id = {currentEquipment.ItemId}");
}
data.Equipment[slot] = currentEquipment.ItemId;
_resources.SpendItem(currentEquipment.ItemId, 1);
LogicLog.SetEquip(unitId, currentEquipment.ItemId, slot, data.EquipmentStars);
}
public override bool Check(IUnitConditionUnitClass restictionData)
{
if (_battle.ContextCondition.IsEnemy)
{
return(false);
}
var unit = _units.GetUnit(_battle.ContextCondition.CurrentTarget);
return(unit.unit?.ClassId == restictionData.ClassId);
}
public void SetUnitExplorer(int unitId, int slotExplorer)
{
var oldUnit = 0;
foreach (var unit in _units.State.LastTeam)
{
if (unit.Value == slotExplorer)
{
oldUnit = unit.Key;
_units.GetUnit(oldUnit).data.ExplorerPosition = -1;
break;
}
}
_units.State.LastTeam.Remove(oldUnit);
if (unitId != 0)
{
_units.State.LastTeam[unitId] = slotExplorer;
}
}
public void UnitUpgrateLevel(int unitId)
{
var(data, unit) = _units.GetUnit(unitId);
var playerLevel = _player.State.Level;
if (data.Level >= playerLevel)
{
throw new Exception($"Unable to level up unit. Unit id = {unitId} unit level = {data.Level} current player level = {playerLevel}");
}
var prices = _units.GetLevel(data.Level + 1)?.Prices;
if (prices != null)
{
foreach (var price in prices)
{
_scorers.Spend(price.Value, _formuls);
}
}
data.Exp = 0;
data.Level++;
_impact.ExecuteContextImpact(unit.ImpactUpdrade, unitId);
}
public override double Calculate(IFormulaPerkRarity formulaData)
{
var max = 0;
foreach (var unitId in _units.ExplorerUnits)
{
var(state, unit) = _units.GetUnit(unitId);
if (state.PerkStars.TryGetValue(formulaData.PerkId, out var maxUnit))
{
max = Mathf.Max(maxUnit, max);
}
}
return(max);
}
public void ActivationObject(int id, int index, PerkExecuteData data, ExplorerPositionData position)
{
_changeLogic.SetMode(ApplyMode.Manual);
LogicLog.Activate(id, index);
var activation = _explorer.GetActivation(id, index);
_explorer.State.Position = position;
_impactLogic.ExecuteImpact(activation.Impact);
var staminaId = _scorers.StaminaId;
if (data != null)
{
var perk = _units.Static.Perks[data.PerkId];
if (perk.ClassId != activation.Source.PerkClassId)
{
throw new Exception($"Perk cannot be applied. UnitId = {data.UnitId} perkId = {data.PerkId} perk class id = {perk.ClassId} activation perkClassId = {activation.Source.PerkClassId}");
}
if (activation.Source.UnitId != 0 && activation.Source.UnitId != data.UnitId)
{
throw new Exception($"Perk cannot be applied. UnitId = {data.UnitId} need unit id = {activation.Source.UnitId}");
}
var(unit, _) = _units.GetUnit(data.UnitId);
if (!unit.PerkStars.TryGetValue(data.PerkId, out var stars) || stars < activation.Source.PerkLevel)
{
throw new Exception($"Not enough stars to use the perk. UnitId = {data.UnitId} perkId = {data.PerkId} perkStars = {stars} activation stars = {activation.Source.PerkLevel} ");
}
if (!unit.PerkCharges.TryGetValue(data.PerkId, out var value) || value == 0)
{
throw new Exception($"НNot enough stars to use the perk. UnitId = {data.UnitId} perkId = {data.PerkId}");
}
unit.PerkCharges[data.PerkId]--;
}
else
{
if (activation.Source.PerkClassId != 0)
{
throw new Exception($"Can't complete activation without perk. activation perkClassId = {activation.Source.PerkClassId}");
}
}
//_explorer.SpendScorer(staminaId, (int)_formulaLogic.Calculate(activation.Cost.Stamina));
//_explorer.ActivateInteractiveObject(id);
_explorer.State.LastInteractiveId = id;
_changeLogic.BatchCutScene(0);
_changeLogic.SetMode(ApplyMode.Auto);
}
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 ClearBattle()
{
foreach (var temp in _battle.State.Data.Allies)
{
if (_units.State.Units.FirstOrDefault(x => x.Id == temp.Value.StaticId) == null && temp.Value.Assist)
{
continue;
}
var unit = _units.GetUnit(temp.Value.StaticId);
unit.data.CurrentHp = temp.Value.CurrentHp;
foreach (var buff in temp.Value.Buffs)
{
unit.data.Buffs[buff.Key] = buff.Value.CountStack;
}
}
_battle.State.Data = null;
}
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 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 double Calculate(IFormulaUnitsParam formulaData)
{
if (!_battle.Static.BattleParams.TryGetValue(formulaData.Param, out var param))
{
//var param = _battle.Static.BattleParams[formulaData.Param];
Logger.Error($"FormulaUnitParam no param id = {formulaData.Param}. return 1", this);
return(1);
}
switch (param.Label)
{
case ParamType.EnergyMax:
return(_formula.Calculate(_player.GetLevel(_player.State.Level).EnergyMax));
case ParamType.UnitEquipStars:
if (_context.ContextFormula == null)
{
return(1);
}
if (_units.TryGetUnit(_context.ContextFormula.Value, true, out var unitData))
{
return(unitData.EquipmentStars);
}
else
{
return(1);
}
}
if (_context.NeedExploreParam || !_context.BattleMode)
{
if (_context.ContextFormula == null)
{
return(1);
}
var(data1, unit) = _units.GetUnit(_context.ContextFormula.Value);
var sum = 0;
switch (param.Label)
{
case ParamType.UserLevel:
return(data1.Level);
case ParamType.UnitHp:
return(data1.CurrentHp);
case ParamType.UnitStrength:
return(_formula.Calculate(unit.Strength));
case ParamType.UnitStrBase:
return(unit.Rarities.Where(x => x.Value.Stars == data1.Stars).Sum(x => x.Value.Strength));
case ParamType.UnitStrEquip:
return(_units.CalculateEquipStrength(_context.ContextFormula.Value));
case ParamType.UnitHpMax:
return(_formula.Calculate(unit.HpMax));
case ParamType.UnitHpBase:
return(unit.Rarities.Where(x => x.Value.Stars == data1.Stars).Sum(x => x.Value.HpMax));
case ParamType.UnitHpEquip:
return(_units.CalculateEquipHp(_context.ContextFormula.Value));
case ParamType.UnitInitiative:
return(_formula.Calculate(unit.Initiative));
case ParamType.UnitInitBase:
return(unit.Rarities.Where(x => x.Value.Stars == data1.Stars).Sum(x => x.Value.Initiative));
case ParamType.UnitInitEquip:
return(_units.CalculateEquipInit(_context.ContextFormula.Value));
case ParamType.UnitAblBase:
return(GetAbilityParam(unit.Id, AbilityType.BaseAttack));
case ParamType.UnitAblFamiliar:
return(GetAbilityParam(unit.Id, AbilityType.UpgradeAttack));
case ParamType.UnitAblUlta:
return(GetAbilityParam(unit.Id, AbilityType.Ultimate));
case ParamType.UnitStamina:
return(unit.Rarities.Where(x => x.Value.Stars == data1.Stars).Sum(x => x.Value.Stamina));
}
return(1);
}
IMemberBattleData member = _context.GetMember(formulaData.TargetType);
if (member == null)
{
Logger.Error($"FormulaUnitParam no param id = {formulaData.Param} return 1", this);
return(1);
}
switch (param.Label)
{
case ParamType.UserLevel:
return(1);
case ParamType.UnitHp:
return(member.CurrentHp);
case ParamType.UnitStrength:
return(member.Strength.Value);
case ParamType.UnitStrBase:
return(member.Strength.Base);
case ParamType.UnitStrEquip:
return(member.Strength.Equip);
case ParamType.UnitHpMax:
return(member.HpMax.Value);
case ParamType.UnitHpBase:
return(member.HpMax.Base);
case ParamType.UnitHpEquip:
return(member.HpMax.Equip);
case ParamType.UnitInitiative:
return(member.Initiative.Value);
case ParamType.UnitInitBase:
return(member.Initiative.Base);
case ParamType.UnitInitEquip:
return(member.Initiative.Equip);
case ParamType.UnitAblBase:
return(member.MemberType == BattleMemberType.Unit ? GetAbilityParam(member.StaticId, AbilityType.BaseAttack) : 0);
case ParamType.UnitAblFamiliar:
return(member.MemberType == BattleMemberType.Unit ? GetAbilityParam(member.StaticId, AbilityType.UpgradeAttack) : 0);
case ParamType.UnitAblUlta:
return(member.MemberType == BattleMemberType.Unit ? GetAbilityParam(member.StaticId, AbilityType.Ultimate) : 0);
default:
throw new ArgumentOutOfRangeException(param.Label);
}
float GetAbilityParam(int id, AbilityType type)
{
var ability = _units.Static.Abilities.Values.FirstOrDefault(y => y.Params.UnitId == id && y.Params.Mode == type);
if (ability == null)
{
Logger.Error($"FormulaUnitParam param id = {formulaData.Param}. userId = {id} abilityType = {type} no ability. return 1", this);
return(1);
}
if (!_units.GetUnit(id).data.Abilities.TryGetValue(ability.Id, out var level))
{
Logger.Error($"FormulaUnitParam param id = {formulaData.Param}. userId = {id} abilityType = {type} no ability. return 1", this);
return(1);
}
return(level);
}
}
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);
}
}
}