void Awake()
{
owner = GetComponentInParent <CharacterCharacter> ();
movement = GetComponentInChildren <Mover> ();
classAbilities = GetComponentsInChildren <Ability> ();
nextLevel = GetComponentInChildren <ClassSpecifications> ();
passives = new List <ContinuousEffect>();
}
public void getRatio(List <CharacterCharacter> enemy, CharacterCharacter c)
{
ratio = new double[enemy.Count];
for (int i = 0; i < enemy.Count; i++)
{
ratio[i] = ((double)enemy[i].type.morale / distance(enemy[i].x, enemy[i].y, c.x, c.y)) / (1f * enemy[i].currentHP / enemy[i].type.maximumHealth);
}
}
public override void AIUse(CharacterCharacter target)
{
range = specs.range;
target.activeEffects.Add(new Slowed(target, turns, movementReduction));
Start();
specs.owner.usedAbility = true;
cooldownTimer = cooldown;
}
public new void Init(CharacterCharacter c, int rounds)
{
base.Init(c, rounds);
changeInDamage = (int)(c.type.attack * 0.1);
c.type.attack += changeInDamage;
c.type.defense += 2;
type = ActiveEffect.EffectType.buff;
}
public override void AIUse(CharacterCharacter target)
{
range = specs.range;
target.activeEffects.Add(new Sheepified(target));
Start();
specs.owner.usedAbility = true;
cooldownTimer = cooldown;
}
public new void Init(CharacterCharacter c, int rounds)
{
base.Init(c, rounds);
percentDamageIncrease = 1.3;
changeInDamage = (int)(c.type.attack * (percentDamageIncrease - 1));
c.type.attack += changeInDamage;
type = ActiveEffect.EffectType.buff;
}
public override void AIUse(CharacterCharacter target)
{
damage = specs.attack / 3.0;
range = specs.range;
target.activeEffects.Add(new Poisoned(target, damage, 3));
Start();
specs.owner.usedAbility = true;
cooldownTimer = cooldown;
}
public void Init(CharacterCharacter c, double d, int rounds)
{
this.c = c;
base.Init(c, rounds);
DOT = d;
SpriteRenderer sr = c.gameObject.GetComponent <SpriteRenderer> ();
sr.color = new Color(0, 1, 0, 1);
}
public new void Init(CharacterCharacter c, int rounds)
{
base.Init(c, rounds);
percentHealthIncrease = 1.2;
changeInMaxHP = Dround((c.type.maximumHealth * (percentHealthIncrease - 1)));
c.type.maximumHealth += changeInMaxHP;
c.currentHP = Dround((c.currentHP * percentHealthIncrease));
type = ActiveEffect.EffectType.buff;
}
public new void Init(CharacterCharacter c, int rounds)
{
attackBonus = Dround(c.type.attack * (attackPercent));
healthBonus = Dround(c.type.maximumHealth * (healthPercent));
base.Init(c, rounds);
lastTile = c.tile;
NewTile();
specs = c.type;
}
void TransferEffects(CharacterCharacter c)
{
foreach (ActiveEffect e in buffs)
{
e.Finish();
c.activeEffects.Remove(e);
specs.owner.activeEffects.Add(e.Clone(specs.owner));
}
}
public override void AIUse(CharacterCharacter target)
{
damage = specs.attack;
range = specs.range;
target.damage(damage + extraDamage);
target.activeEffects.Add(new Slowed(target));
Start();
specs.owner.usedAbility = true;
cooldownTimer = cooldown;
}
public bool Contains(CharacterCharacter p)
{
foreach (CharacterCharacter c in pieces)
{
if (c == p)
{
return(true);
}
}
return(false);
}
void TakeDebuffs(CharacterCharacter c)
{
foreach (ActiveEffect e in c.activeEffects)
{
if (e.type == ActiveEffect.EffectType.debuff)
{
buffs.Add(e);
}
}
cooldown = 6;
}
public new void Init(CharacterCharacter c, int rounds)
{
base.Init(c, rounds);
ultCD = false;
foreach (Ability a in c.specialAbilities)
{
if (a.ultimate)
{
ultimate = a;
}
}
}
//adds passives for characters as effects
void addPassive(CharacterCharacter c)
{
if (c.type.type == ClassSpecifications.CharacterType.Swordsman)
{
c.type.passive = new Stalwart(c);
c.activeEffects.Add(c.type.passive);
}
if (c.type.type == ClassSpecifications.CharacterType.Alchemist)
{
c.type.passive = new ParadigmShift(c);
c.activeEffects.Add(c.type.passive);
}
if (c.type.type == ClassSpecifications.CharacterType.Bard)
{
c.type.passive = new RisingTempo(c);
c.activeEffects.Add(c.type.passive);
}
if (c.type.type == ClassSpecifications.CharacterType.Priest)
{
c.type.passive = new Martyr(c);
c.activeEffects.Add(c.type.passive);
}
if (c.type.type == ClassSpecifications.CharacterType.Hero)
{
c.type.passive = new IncomprehensibleRage(c);
c.activeEffects.Add(c.type.passive);
}
if (c.type.type == ClassSpecifications.CharacterType.Noble)
{
c.type.passive = new TacticalManeuver(c);
c.activeEffects.Add(c.type.passive);
}
if (c.type.type == ClassSpecifications.CharacterType.Thief)
{
c.type.passive = new AcrobaticLeap(c);
c.activeEffects.Add(c.type.passive);
}
if (c.type.type == ClassSpecifications.CharacterType.Magician)
{
c.type.passive = new FantasiasReturn(c);
c.activeEffects.Add(c.type.passive);
}
c.type.passives.Add(c.type.passive);
}
public new void Init(CharacterCharacter c, int rounds)
{
base.Init(c, rounds);
if (c.type.defense < 10)
{
changeInDefense = c.type.defense;
}
else
{
changeInDefense = 10;
}
c.type.defense -= changeInDefense;
type = ActiveEffect.EffectType.debuff;
}
public override void AIUse(CharacterCharacter target)
{
damage = specs.attack;
range = specs.range;
int count = 0;
charachterTargets = new List <CharacterCharacter>();
foreach (CharacterCharacter c in base.GetTargetsInRange(specs.owner.x, specs.owner.y, specs.range))
{
if (c.team != specs.owner.team && count < numberOfTargets)
{
charachterTargets.Add(c);
count++;
}
}
foreach (CharacterCharacter c in charachterTargets)
{
int originalX = c.x;
int originalY = c.y;
//x and y are in the array of tiles
TileAttributes tile;
int x = Math.Min(1, Math.Max(-1, (int)(c.x - specs.owner.x)));
int y = Math.Min(1, Math.Max(-1, (int)(c.y - specs.owner.y)));
c.x += x;
c.y += y;
c.x = Math.Max(0, Math.Min(c.x, specs.owner.team.map.HighX - specs.owner.team.map.LowX));
c.y = Math.Max(0, Math.Min(c.y, specs.owner.team.map.HighY - specs.owner.team.map.LowY));
tile = specs.owner.team.map.tileMap[c.x, c.y];
if (tile.containedCharacter != null || tile.type == TileAttributes.TileType.water)
{
c.x = originalX;
c.y = originalY;
}
else
{
c.tile.containedCharacter = null;
c.tile = tile;
tile.containedCharacter = c;
c.transform.position = tile.transform.position;
}
c.damage(damage);
}
Start();
specs.owner.usedAbility = true;
cooldownTimer = cooldown;
}
/** Stealthed Targets are not targetable, integrated into CharacterTargeter, in "GetTargetsInRange" method**/
public override void Init(CharacterCharacter c, int rounds)
{
base.Init(c, rounds);
changeInAttack = c.type.attack - 2;
c.type.attack = 2;
percentHealthDecrease = .5;
changeInHealth = Dround((c.type.maximumHealth * (percentHealthDecrease - 1)));
c.type.maximumHealth += changeInHealth;
c.currentHP = Dround((c.currentHP * percentHealthDecrease));
changeInDefense = Dround((c.type.defense * (percentHealthDecrease - 1)));
c.type.defense += changeInDefense;
type = ActiveEffect.EffectType.debuff;
}
public override void AIUse(CharacterCharacter target)
{
damage = specs.attack + 3;
range = specs.range;
tileTargets = new List <TileAttributes>();
tileTargets.Add(target.tile);
base.GetFullTargets(size);
foreach (TileAttributes t in fullTileTargets)
{
specs.owner.team.tileEffects.Add(new PoisonedTile(t, specs.owner.team, damage));
}
Start();
specs.owner.usedAbility = true;
cooldownTimer = cooldown;
}
public override void AIUse(CharacterCharacter target)
{
range = specs.range;
tileTargets = new List <TileAttributes>();
tileTargets.Add(target.tile);
base.GetFullTargets(size);
foreach (TileAttributes t in fullTileTargets)
{
if (t.containedCharacter != null && t.containedCharacter.team != specs.owner.team)
{
t.containedCharacter.activeEffects.Add(new Stunned(t.containedCharacter));
}
}
Start();
specs.owner.usedAbility = true;
cooldownTimer = cooldown;
}
public CharacterCharacter findClosest(CharacterCharacter ai)
{
CharacterCharacter nearestEnemy = null;
double minDistance = 9001.0;
foreach (Team t in map.teams.teams)
{
foreach (CharacterCharacter c in t.pieces)
{
if (c.team != ai.team)
{
if (distance(c.x, c.y, ai.x, ai.y) < minDistance)
{
minDistance = distance(c.x, c.y, ai.x, ai.y);
nearestEnemy = c;
}
}
}
}
return(nearestEnemy);
}
void SwapPositions(CharacterCharacter c1, CharacterCharacter c2)
{ /*
* t.containedCharacter = moved.owner;
* moved.owner.tile.containedCharacter = null;
* moved.owner.tile = t;
* moved.owner.transform.position = t.transform.position;
* moved.owner.x = t.x;
* moved.owner.y = t.y;
*/
TileAttributes[] tiles = { c1.tile, c2.tile };
int[] positionOfC1 = { c1.x, c1.y };
c1.tile = tiles[1];
c2.tile = tiles[0];
c1.tile.containedCharacter = c1;
c2.tile.containedCharacter = c2;
c1.transform.position = tiles[1].transform.position;
c2.transform.position = tiles[0].transform.position;
c1.x = c2.x;
c1.y = c2.y;
c2.x = positionOfC1[0];
c2.y = positionOfC1[1];
}
public override void AIUse(CharacterCharacter target)
{
int count = 0;
chance = (int)Random.Range(1, 4);
charachterTargets = new List <CharacterCharacter>();
foreach (CharacterCharacter c in base.GetAllTargetsInRange(specs.owner.x, specs.owner.y, specs.range))
{
if (c.team == specs.owner.team && count < numberOfTargets)
{
charachterTargets.Add(c);
count++;
}
}
foreach (CharacterCharacter c in charachterTargets)
{
if (chance == 1)
{
c.activeEffects.Add(new ElixirHealth(c));
}
else if (chance == 2)
{
c.activeEffects.Add(new ElixirDamage(c));
}
else if (chance == 3)
{
c.activeEffects.Add(new ElixirSpeed(c));
}
else
{
c.activeEffects.Add(new ElixirDefense(c));
}
}
Start();
specs.owner.usedAbility = true;
cooldownTimer = cooldown;
}
public override void AIUse(CharacterCharacter target)
{
int count = 0;
charachterTargets = new List <CharacterCharacter>();
foreach (CharacterCharacter c in base.GetTargetsInRange(specs.owner.x, specs.owner.y, specs.range))
{
if (c != null & c.team != specs.owner.team && count < numberOfTargets)
{
charachterTargets.Add(c);
count++;
}
}
foreach (CharacterCharacter t in charachterTargets)
{
t.damage(damage);
}
Start();
specs.owner.usedAbility = true;
cooldownTimer = cooldown;
}
List <CharacterCharacter> inRange(int x, int y, float range, CharacterCharacter host)
{
List <CharacterCharacter> charTargets = new List <CharacterCharacter> ();
foreach (Team t in map.teams.teams)
{
foreach (CharacterCharacter c in t.pieces)
{
if (c.team != host.team)
{
int rsqrd = (int)(range * range);
int dxsqrd = (x - c.x) * (x - c.x);
int dysqrd = (y - c.y) * (y - c.y);
bool b = !(x == c.x && y == c.y);
if ((rsqrd >= dxsqrd + dysqrd) && b)
{
charTargets.Add(c);
}
}
}
}
return(charTargets);
}
public override void AIUse(CharacterCharacter target)
{
int count = 0;
addedHealth = specs.attack * 2;
range = specs.range;
foreach (CharacterCharacter c in base.GetTargetsInRange(specs.owner.x, specs.owner.y, specs.range))
{
if (c.team == specs.owner.team && count < numberOfTargets)
{
charachterTargets.Add(c);
count++;
}
else
{
foreach (CharacterCharacter c2 in charachterTargets)
{
if (c.team == specs.owner.team && c.currentHP < c2.currentHP)
{
charachterTargets.Remove(c2);
charachterTargets.Add(c);
break;
}
}
}
}
foreach (CharacterCharacter t in charachterTargets)
{
t.heal(addedHealth);
}
Start();
specs.owner.usedAbility = true;
cooldownTimer = cooldown;
}
public void moveTowardsHighThreat(CharacterCharacter ai, CharacterCharacter c)
{
List <TileAttributes> possibleMoves = new List <TileAttributes>();
double closest = 9001.0;
int closestIndex = 0;
possibleMoves = ((LimitedSpaces)(ai.type.movement)).GetPossibleMoves();
if (possibleMoves.Count != 0)
{
for (int i = 0; i < possibleMoves.Count; i++)
{
if (Math.Abs(distance(possibleMoves[i].x, possibleMoves[i].y, c.x, c.y) - (ai.type.range)) < Math.Abs(closest - (ai.type.range)))
{
closest = distance(possibleMoves[i].x, possibleMoves[i].y, c.x, c.y);
closestIndex = i;
}
}
if (Math.Abs(distance(possibleMoves[closestIndex].x, possibleMoves[closestIndex].y, c.x, c.y) - (ai.type.range)) <= Math.Abs(distance(ai.x, ai.y, c.x, c.y) - (ai.type.range)))
{
((LimitedSpaces)(ai.type.movement)).Move(possibleMoves[closestIndex]);
}
}
}
public void DamageOthers(CharacterCharacter t, int d)
{
if (d > 0) //when damage has been done
{
foreach (CharacterCharacter c in linked)
{
if (c != t)
{
c.damage(d);
}
}
}
if (d < 0)
{
foreach (CharacterCharacter c in linked)
{
if (c != t)
{
c.heal(-d);
}
}
}
}
public override void AIUse(CharacterCharacter target)
{
damage = specs.attack + 3;
range = specs.range;
int count = 2;
charachterTargets = new List <CharacterCharacter>();
foreach (CharacterCharacter c in base.GetTargetsInRange(specs.owner.x, specs.owner.y, specs.range))
{
if (c.team != specs.owner.team && count < numberOfTargets)
{
charachterTargets.Add(c);
count++;
}
}
if (count == 2)
{
specs.owner.activeEffects.Add(new BardLinked(specs.owner, charachterTargets));
}
Start();
specs.owner.usedAbility = true;
cooldownTimer = cooldown;
}
