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 override bool Check(IConditionFamiliar restictionData)
{
if (!_units.TryGetUnit(restictionData.UnitId, true, out var unit))
{
return(false);
}
return(unit.FamiliarUnlock);
}
public override void Execute(IImpactFamiliarUnlock data)
{
if (!_logic.TryGetUnit(data.UnitId, true, out var unit))
{
return;
}
LogicLog.UnlockFamiliar(data.UnitId);
unit.FamiliarUnlock = true;
}
public override void Execute(IImpactUnitRemove data)
{
if (_units.TryGetUnit(data.UnitId, false, out var unit))
{
unit.ExplorerPosition = -1;
_units.State.Units.Remove(unit);
_units.State.LastTeam.Remove(data.UnitId);
_units.UpdateLastTeamSlots();
}
}
public override bool Check(IUnitConditionFamiliar restictionData)
{
if (_context.ContextCondition.IsEnemy)
{
return(false);
}
if (!_units.TryGetUnit(_context.ContextCondition.CurrentTarget, true, out var unit))
{
return(false);
}
return(unit.FamiliarUnlock);
}
public override void Execute(IImpactUnitSetSlot impactData)
{
if (_accessor.TryGetUnit(impactData.UnitId, false, out var data))
{
if (data.ExplorerPosition == impactData.SlotId)
{
return;
}
if (impactData.SlotId < 0)
{
_accessor.SetUnitReserve(impactData.UnitId, false);
return;
}
var unit = _accessor.State.Units.FirstOrDefault(x => x.ExplorerPosition == impactData.SlotId);
if (unit == null)
{
data.ExplorerPosition = impactData.SlotId;
}
else
{
if (impactData.Replace)
{
_accessor.SetUnitReserve(unit.Id, false);
data.ExplorerPosition = impactData.SlotId;
}
else
{
var slots = new List <int> {
1, 2, 3
};
foreach (var temp in _accessor.State.Units)
{
slots.Remove(temp.ExplorerPosition);
}
if (slots.Count > 0)
{
data.ExplorerPosition = slots.First();
}
}
}
}
else
{
}
}
public override bool Check(IConditionUnit data)
{
var value = (int)_formula.Calculate(data.RarityValue);
if (!_units.TryGetUnit(data.UnitId, true, out var unit))
{
return(data.Operator.Check(0, value));
}
if (data.InExplorer && !_units.ExplorerUnits.Contains(unit.Id))
{
return(false);
}
if (data.InActive && unit.ExplorerPosition < 0)
{
return(false);
}
return(data.Operator.Check(unit.Stars, value));
}
public double Calculate(IFormula data, int unit)
{
if (_contextLogic.BattleMode && !_battle.LiveAllies.Contains(unit) && !_battle.LiveEnemies.Contains(unit))
{
var enemy = _battle.LiveEnemies.FirstOrDefault(x => _battle.State.Data.Enemies[x].StaticId == unit);
if (enemy == -1)
{
Logger.Error($"no found unit id = {unit}", this);
return(1);
}
unit = enemy;
}
if (!_contextLogic.BattleMode && !_units.TryGetUnit(unit, true, out var _))
{
Logger.Error($"no found unit id = {unit}", this);
return(1);
}
_contextLogic.SetContextFormula(unit);
var value = _formula.Calculate(data);
_contextLogic.SetContextFormula(null);
return(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);
}