IMagicReleaser IBattlePerception.CreateReleaserView(
IBattleCharacter releaser, IBattleCharacter targt, UVector3?targetPos)
{
var obj = new GameObject("MagicReleaser");
obj.transform.SetParent(this.transform, false);
return(obj.AddComponent <UMagicReleaserView> ());
}
// OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
public override void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
character = animator.GetComponent<IBattleCharacter>();
//if (animatorState.idle)
if (animatorState.dead)
character.dyingAnimation();
}
public void takeGeneralDamage(Damage damage, IAbility ability, IBattleCharacter source)
{
List<GameObject> children = listChildren(this.gameObject);
foreach (GameObject child in children)
{
child.GetComponent<IBattleCharacter>().takeGeneralDamage(damage,ability,source);
}
}
void IBattleCharacter.LookAtTarget(IBattleCharacter target)
{
var notify = new Proto.Notify_LookAtCharacter
{
Own = Index,
Target = target.Index
};
this.PerceptionView.AddNotify(notify);
this.transform.LookAt(target.Transform);
}
void IBattlePerception.ProcessDamage(IBattleCharacter sources, IBattleCharacter target, DamageResult result)
{
var notify = new Notify_DamageResult
{
Damage = result.Damage,
IsMissed = result.IsMissed,
Index = sources.Index,
TargetIndex = target.Index
};
AddNotify(notify);
}
public bool updateDuration(IBattleCharacter character)
{
if (turnsElapsed >= totalTurns)
{
return true;
}
turnsElapsed++;
return false;
}
public int HealthAfterCombat(IBattleCharacter player)
{
int randAttack = rand.Next(attack - ATTACK_RANGE, attack + ATTACK_RANGE + 1);
int newHealth = player.Health;
if (player.Defense < randAttack)
{
newHealth -= randAttack - player.Defense;
}
else
{
newHealth -= 1; // Always lose at least 1 HP.
}
return newHealth;
}
public override void takeGeneralDamage(Damage damage, IAbility ability, IBattleCharacter source)
{
base.takeGeneralDamage(damage, ability, source);
}
public void SetCharacter(IBattleCharacter releaser, IBattleCharacter target)
{
CharacterTarget = target;
CharacterReleaser = releaser;
}
public BattleMagicReleaserView(IBattleCharacter releaser, IBattleCharacter target, BattlePerceptionView view) : base(view)
{
CharacterTarget = target;
CharacterReleaser = releaser;
}
IMagicReleaser IBattlePerception.CreateReleaserView(IBattleCharacter releaser, IBattleCharacter targt, UVector3?targetPos)
{
return(new BattleMagicReleaserView(releaser, targt, this));
}
void IBattlePerception.ProcessDamage(IBattleCharacter view1, IBattleCharacter view2, GameLogic.Game.DamageResult result)
{
}
void IBattleCharacter.LookAtTarget(IBattleCharacter target)
{
this.LookAt(target.Transform);
}
public int HealthAfterCombat(IBattleCharacter enemy)
{
// create a random number to see if the attack hit!
int randAttack = rand.Next(attack - ATTACK_RANGE, attack + ATTACK_RANGE + 1);
int didHit = rand.Next(1, 101);
int newHealth = enemy.Health;
if (didHit <= accuracy)
{
if (accuracy == 100)
{
if ((int)((randAttack / 2) - enemy.Defense) > 0)
{
newHealth -= ((int)((randAttack / 2) - enemy.Defense));
}
}
else if (accuracy == 80)
{
if ((int)(randAttack - enemy.Defense) > 0)
{
newHealth -= (randAttack - enemy.Defense);
}
}
else if (accuracy == 55)
{
if (((randAttack * 2) - enemy.Defense) > 0)
{
newHealth -= ((randAttack * 2) - enemy.Defense);
}
}
else if (accuracy == 99)
{
if ((magicAtk - enemy.Defense) > 0 && magicAtk >= 2)
{
newHealth -= magicAtk - enemy.Defense;
}
}
else if (accuracy == 98)
{
if ((magicAtk - enemy.Defense) > 0 && magicAtk >= 6)
{
newHealth -= magicAtk + 5 - enemy.Defense;
}
}
if (newHealth < 0)
{
newHealth = 0;
}
}
else
{
return -1;
}
return newHealth;
}
public virtual void takeGeneralDamage(Damage damage, Ability.IAbility ability, IBattleCharacter source)
{
if (ability.getStatusEffectTypes() != null)
{
addStatusEffect(ability.getStatusEffectTypes());
}
if (this.getCharStats().targetCurHP <= 0)
return;
float modifier = UnityEngine.Random.Range(0.9f, 1.1f);
damage.actualDamage = (int)((float)playerStats.calculateDamageTaken(damage.baseDamage, ability.getAbilityClass()) * modifier);
takeDamage(damage, ability.show0Damage(), ability.timeToDamage());
}
public int calculateStatusEffect(Ability.StatusEffectType statusEffectType, IBattleCharacter character, bool reset = false)
{
offenseDamageMultiplier = 1;
int totalDamage = 0;
switch(statusEffectType.status)
{
case Ability.StatusEffectType.StatusTypes.Curse:
break;
case Ability.StatusEffectType.StatusTypes.Death:
break;
case Ability.StatusEffectType.StatusTypes.Haste:
break;
case Ability.StatusEffectType.StatusTypes.Poison:
totalDamage = character.getCharStats().calculateTurnStatusDamage(statusEffectType).actualDamage;
break;
case Ability.StatusEffectType.StatusTypes.Raise:
if (this.dead)
{
this.dead = false;
}
else
{
break;
}
curHP = 0;
targetCurHP = (int) (statusEffectType.potency * maxHP);
break;
case Ability.StatusEffectType.StatusTypes.Regen:
break;
case Ability.StatusEffectType.StatusTypes.Slow:
break;
case Ability.StatusEffectType.StatusTypes.Wait:
if (!reset)
offenseDamageMultiplier -= 0.5f;
break;
default:
throw new System.NotImplementedException();
}
return totalDamage;
}
