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);
}
/**
* Se le resta el valor de descuento al ataque
*/
public float descontar(iAttack <float> descuento)
{
float recibido = 0f;
var cp = atq.copy();
atq.remAttack(descuento);
foreach (var item in getTypes())
{
recibido += cp.getAttack(item) - atq.getAttack(item);
}
return(recibido);
}
/**
* 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> .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);
}
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)));
}
public Damage(iAttack <float> attack)
{
atq = attack;
}
