public void AttackWithKnockback_DamagesCharacter()
{
HeroSystemCharacter attacker = new HeroSystemCharacter();
Attack cm = new Attack("Basic", attacker, DamageType.Normal, 5,
DefenseType.PD);
DamageAmount attackDamage = new DamageAmount();
attackDamage.Type = DamageType.Normal;
attackDamage.BOD = 13;
attackDamage.WorksAgainstDefense = DefenseType.PD;
HeroSystemCharacter defender = new HeroSystemCharacter();
KnockbackResult actualKnockback = cm.KnockBackCharacter(defender, attackDamage);
KnockbackResultType actualResult = actualKnockback.Result;
KnockbackResultType expectedResult = KnockbackResultType.KnockBacked;
Assert.AreEqual(actualResult, expectedResult);
bool isProne = defender.State.ContainsKey(CharacterStateType.Prone);
Assert.AreEqual(isProne, true);
}
void Awake()
{
// Setting up the references.
player = GameObject.FindGameObjectWithTag("Player");
playerHealth = player.GetComponent <Health> ();
damage = GetComponent <DamageAmount>();
enemyHealth = GetComponent <EnemyHealth>();
anim = GetComponent <Animator> ();
}
private void UpdateAnimatorLayerByDamage(DamageAmount newDamageLayer)
{
print("Updating layer " + _damageTaken + " to 0.0 and layer " + newDamageLayer + " to 1");
if (_damageTaken != DamageAmount.NONE)
{
Animator.SetLayerWeight((int)_damageTaken, 0.0f);
}
Animator.SetLayerWeight((int)newDamageLayer, 1.0f);
}
public DamageAmount DeductDefenseFromDamage(DamageAmount damageAmount)
{
//to do: put state logic into body and stun charasteristics
Charasteristic defense = determineDefense(damageAmount);
DamageAmount damageDone = damageAmount.Clone();
damageDone.STUN -= defense.CurrentValue;
damageDone.BOD -= defense.CurrentValue;
return(damageDone);
}
public override void firedFrontWeapon(GameObject[] bullet, Vector3 whichPositionFiredFrom, float angleTravel)
{
foreach (GameObject shot in bullet)
{
DamageAmount damageAmount = shot.GetComponent <DamageAmount>();
if (damageAmount != null)
{
damageAmount.addDamage(3);
}
}
}
private void CheckDamageTaken()
{
var currentDamageTaken = CalculateDamageTaken();
if (_damageTaken != currentDamageTaken)
{
// update the damage to be the current and update layers
UpdateAnimatorLayerByDamage(currentDamageTaken);
_damageTaken = currentDamageTaken;
}
}
public override void firedRightWeapon(GameObject[] bullet, Vector3 spawnPosition, float angleTravel)
{
foreach (GameObject bulletInstant in bullet)
{
DamageAmount damageAmount = bulletInstant.GetComponent <DamageAmount>();
if (damageAmount != null)
{
damageAmount.addDamage(damageBonus);
damageBonus = 0;
}
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.layer == 16) // Is player projectile?
{
DamageAmount damageInstant = collision.gameObject.GetComponent <DamageAmount>();
if (damageInstant != null)
{
Instantiate(empowerEffect, collision.transform.position, Quaternion.identity);
damageInstant.originDamage = damageInstant.originDamage + attackSteroid;
damageInstant.updateDamage();
}
}
}
void OnTriggerEnter(Collider col)
{
Debug.Log(col.gameObject.name);
DamageAmount damage = col.gameObject.GetComponent <DamageAmount>();
if (damage)
{
/*
* EnemyHealth enemyHealth = col.gameObject.GetComponent<EnemyHealth> ();
* enemyHealth.Kill ();
*/
//playerHealth.damage(damage.GetDamage());
}
}
public virtual bool Hits(BaseCharacter attacker, BaseCharacter target)
{
CriticalHit = false;
bool hits = false;
switch (Type)
{
case ActionType.MeleeAttack:
case ActionType.RangedAttack:
case ActionType.SpellAttack:
hits = AttackType(attacker, target);
Result = hits ? DamageAmount.Full : DamageAmount.None;
break;
case ActionType.SpellSave:
hits = !target.SavingThrow(Ability, DC);
if (hits && EffectToApply != null)
{
target.ActiveEffect = EffectToApply;
}
if (HalfDamageOnMiss)
{
Result = hits ? DamageAmount.Full : DamageAmount.Half;
hits = true;
}
else
{
Result = hits ? DamageAmount.Full : DamageAmount.None;
}
break;
case ActionType.Heal:
hits = true;
Result = DamageAmount.Full;
break;
case ActionType.GrantTempHp:
hits = true;
Result = DamageAmount.Full;
break;
default:
hits = false;
Result = DamageAmount.None;
break;
}
return(hits);
}
public void TestTakeDamage_EffectsCharacterStateBasedOnAmount()
{
DamageAmount attackDamage = new DamageAmount();
attackDamage.STUN = 35;
attackDamage.BOD = 5;
attackDamage.WorksAgainstDefense = DefenseType.PD;
HeroSystemCharacter defender = new HeroSystemCharacter();
defender.PD.CurrentValue = 5;
defender.STUN.CurrentValue = 50;
defender.BOD.CurrentValue = 10;
defender.BOD.MaxValue = 10;
defender.CON.CurrentValue = 29;
defender.TakeDamage(attackDamage);
bool actualStunned = defender.State.ContainsKey(CharacterStateType.Stunned);
bool expectedStunned = true;
Assert.AreEqual(actualStunned, expectedStunned);
attackDamage = new DamageAmount();
attackDamage.STUN = 35;
attackDamage.BOD = 10;
attackDamage.WorksAgainstDefense = DefenseType.PD;
defender.TakeDamage(attackDamage);
bool actualUnconsious = defender.State.ContainsKey(CharacterStateType.Unconsious);
bool expectedUnconsious = true;
Assert.AreEqual(actualUnconsious, expectedUnconsious);
attackDamage.BOD = 11;
defender.TakeDamage(attackDamage);
bool actualDying = defender.State.ContainsKey(CharacterStateType.Dying);
bool expectedDying = true;
Assert.AreEqual(actualDying, expectedDying);
attackDamage.BOD = 14;
defender.TakeDamage(attackDamage);
bool actualDead = defender.State.ContainsKey(CharacterStateType.Dying);
bool expectedDead = true;
Assert.AreEqual(actualDead, expectedDead);
}
private Charasteristic determineDefense(DamageAmount damage)
{
switch (damage.WorksAgainstDefense)
{
case DefenseType.PD:
return(PD);
case DefenseType.ED:
return(ED);
case DefenseType.RED:
return(RED);
case DefenseType.RPD:
return(RPD);
}
return(null);
}
void firePowerShot(GameObject[] bullets)
{
numberBulletsFired++;
if (numberBulletsFired == 4)
{
foreach (GameObject bullet in bullets)
{
DamageAmount damageAmount = bullet.GetComponent <DamageAmount>();
damageAmount.originDamage += 3;
damageAmount.updateDamage();
}
PlayerScript playerScript = PlayerProperties.playerScript;
float angleTravel = Mathf.Atan2(PlayerProperties.cursorPosition.y - PlayerProperties.playerShipPosition.y, PlayerProperties.cursorPosition.x - PlayerProperties.playerShipPosition.x) + Mathf.PI;
playerScript.setPlayerMomentum(new Vector3(Mathf.Cos(angleTravel), Mathf.Sin(angleTravel)) * 8, 0.75f);
numberBulletsFired = 0;
}
}
public Dictionary <CharacterStateType, HeroCharacterState> TakeDamage(DamageAmount damageAmount)
{
DamageAmount damageDone = DeductDefenseFromDamage(damageAmount);
if (IsRolling == true)
{
damageDone.STUN /= 2;
damageDone.BOD /= 2;
ActiveManuever = null;
}
STUN.Deduct(damageDone.STUN);
BOD.Deduct(damageDone.BOD);
var statesResultingFromDamage = applyDamageStateBasedOnDamageAmount(damageDone);
return(statesResultingFromDamage);
}
public void TestRoll_ReturnsCorrectBodyBasedOnDiceValuesAndStunBasedOnMultipler()
{
KillingDamageDicePool dp = new KillingDamageDicePool(3);
dp.Roll();
Dice[] pool = dp.Pool;
((KillingDamageDice)pool[0]).Body = 3;
((KillingDamageDice)pool[1]).Body = 4;
((KillingDamageDice)pool[2]).Body = 6;
DamageAmount result = dp.DamageResult;
int expectedBody = 13;
int actualBody = result.BOD;
int expectedStun = 13 * dp.Multiplier;
int actualStun = result.STUN;
Assert.AreEqual(expectedBody, actualBody);
Assert.AreEqual(expectedStun, actualStun);
}
public void TestRoll_ReturnsCorrectStunAndBodyBasedOnDiceValues()
{
NormalDamageDicePool dp = new NormalDamageDicePool(3);
dp.Roll();
Dice[] pool = dp.Pool;
((NormalDamageDice)pool[0]).Stun = 3;
((NormalDamageDice)pool[1]).Stun = 4;
((NormalDamageDice)pool[2]).Stun = 6;
DamageAmount result = dp.DamageResult;
int expectedBody = 4;
int actualBody = result.BOD;
int expectedStun = 13;
int actualStun = result.STUN;
Assert.AreEqual(expectedBody, actualBody);
Assert.AreEqual(expectedStun, actualStun);
}
// Update is called once per frame
void Update()
{
if (PlayerHealth.Health >= 25)
{
amount = DamageAmount.none;
}
else if (PlayerHealth.Health <= 20 && PlayerHealth.Health >= 15)
{
amount = DamageAmount.small;
}
else if (PlayerHealth.Health < 15 && PlayerHealth.Health >= 10)
{
amount = DamageAmount.medium;
}
else if (PlayerHealth.Health < 10 && PlayerHealth.Health >= 5)
{
amount = DamageAmount.large;
}
switch (UIAmmoController.Type)
{
case GunType.HandGun:
{
LaserGunIcon.gameObject.SetActive(false);
SMGGunIcon.gameObject.SetActive(false);
SniperGunIcon.gameObject.SetActive(false);
HandGunIcon.gameObject.SetActive(true);
GrenadeIcon.gameObject.SetActive(false);
} break;
case GunType.SMGGun:
{
LaserGunIcon.gameObject.SetActive(false);
HandGunIcon.gameObject.SetActive(false);
SniperGunIcon.gameObject.SetActive(false);
SMGGunIcon.gameObject.SetActive(true);
GrenadeIcon.gameObject.SetActive(false);
} break;
case GunType.LaserGun:
{
LaserGunIcon.gameObject.SetActive(true);
HandGunIcon.gameObject.SetActive(false);
SniperGunIcon.gameObject.SetActive(false);
SMGGunIcon.gameObject.SetActive(false);
GrenadeIcon.gameObject.SetActive(false);
} break;
case GunType.Sniper:
{
LaserGunIcon.gameObject.SetActive(false);
HandGunIcon.gameObject.SetActive(false);
SniperGunIcon.gameObject.SetActive(true);
SMGGunIcon.gameObject.SetActive(false);
GrenadeIcon.gameObject.SetActive(false);
} break;
case GunType.Granade:
{
LaserGunIcon.gameObject.SetActive(false);
HandGunIcon.gameObject.SetActive(false);
SniperGunIcon.gameObject.SetActive(false);
SMGGunIcon.gameObject.SetActive(false);
GrenadeIcon.gameObject.SetActive(true);
} break;
}
switch (amount)
{
case DamageAmount.none:
{
foreach (var img in bloodEffect)
{
img.gameObject.SetActive(false);
}
} break;
case DamageAmount.small:
{
bloodEffect[0].gameObject.SetActive(true);
bloodEffect[1].gameObject.SetActive(false);
bloodEffect[2].gameObject.SetActive(false);
} break;
case DamageAmount.medium:
{
bloodEffect[0].gameObject.SetActive(false);
bloodEffect[1].gameObject.SetActive(true);
bloodEffect[2].gameObject.SetActive(false);
} break;
case DamageAmount.large:
{
bloodEffect[0].gameObject.SetActive(false);
bloodEffect[1].gameObject.SetActive(false);
bloodEffect[2].gameObject.SetActive(true);
} break;
}
}
private Dictionary <CharacterStateType, HeroCharacterState> applyDamageStateBasedOnDamageAmount(DamageAmount damageDone)
{
Dictionary <CharacterStateType, HeroCharacterState> statesResultingFromDamage =
new Dictionary <CharacterStateType, HeroCharacterState>();
HeroCharacterState stateFromDamage = null;
if (damageDone.STUN > CON.CurrentValue)
{
stateFromDamage = AddState(CharacterStateType.Stunned, false);
statesResultingFromDamage.Add(stateFromDamage.Type, stateFromDamage);
InterruptManueverInProgess();
}
if (STUN.CurrentValue <= 0)
{
stateFromDamage = AddState(CharacterStateType.Unconsious, false);
statesResultingFromDamage.Add(stateFromDamage.Type, stateFromDamage);
InterruptManueverInProgess();
}
if (BOD.CurrentValue <= 0 && BOD.CurrentValue > (BOD.MaxValue * -1))
{
stateFromDamage = AddState(CharacterStateType.Dying, false);
statesResultingFromDamage.Add(stateFromDamage.Type, stateFromDamage);
}
else
{
if (BOD.CurrentValue < 0 && BOD.CurrentValue < (BOD.MaxValue * -1))
{
RemoveState(CharacterStateType.Dying);
stateFromDamage = AddState(CharacterStateType.Dead, false);
;
statesResultingFromDamage.Add(stateFromDamage.Type, stateFromDamage);
}
}
return(statesResultingFromDamage);
}
