/**
* Se espera que el que lo invoco sea del tipo fraccionario
*/
public float remanente(iAttack <float> atenuado)
{
float recibido = 0f; //Se podria usar un lindo fold, no?
var atkMax = atenuado.copy().add(atenuado.AttackMax());
foreach (var item in getTypes())
{
recibido += atq.getAttack(item) * atenuado.getAttack(item);
}
atq.mulAttack(atkMax.remAttack(atenuado));
return(recibido);
}
iAttack <T> iAttack <T> .addAttack(iAttack <T> ataque)
{
foreach (string tipo in ataque.getTypes())
{
var buscado = buscarOcrear(tipo);
buscado.add(ataque.getAttack(tipo));
if (buscado.CompareTo(max) == 1)
{
buscado.set(max.get());
}
}
return(this);
}
iAttack <T> iAttack <T> .remAttack(iAttack <T> ataque)
{
foreach (var tipo in ataque.getTypes())
{
var buscado = buscarOcrear(tipo);
buscado.reduce(ataque.getAttack(tipo));
if (buscado.CompareTo(min) == -1)
{
buscado.set(min.get());
}
}
return(this);
}
public void procesarDgm(Damage dmg, float evadio)
{
var max = evasion.AttackMax();
var atkEfectivo = evasion.copy().rem(max);
foreach (string tipo in dmg.getTypes()) //Para cada tipo de ataque del daño
{
if (evasion.getAttack(tipo) > evadio) //Si las chances de evasion se cumplen
{
atkEfectivo.addAttack(new AttackSimple <float>(tipo, new Float(max)));
}
}
dmg.remanente(atkEfectivo);
}
iAttack <T> iAttack <T> .mulAttack(iAttack <float> ataque)
{
foreach (var tipo in ataque.getTypes())
{
var buscado = buscarOcrear(tipo);
buscado.mult(ataque.getAttack(tipo));
if (buscado.CompareTo(max) == 1)
{
buscado.set(max.get());
}
else if (buscado.CompareTo(min) == -1)
{
buscado.set(min.get());
}
}
return(this);
}
iAttack <T> iAttack <T> .mulAttack(iAttack <float> ataque)
{
return(cast().mul(ataque.getAttack(tipo)));
}
iAttack <T> iAttack <T> .remAttack(iAttack <T> ataque)
{
return(cast().rem(ataque.getAttack(tipo)));
}
iAttack <T> iAttack <T> .addAttack(iAttack <T> ataque)
{
return(cast().add(ataque.getAttack(tipo)));
}
