def test_new_health_state_vamp_return_from_torpor(self):
result_vamp = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_TORPOR,
max_health=5,
old_aggravated_damage=1,
new_aggravated_damage=0,
new_superficial_damage=0,
is_vampire=True)
self.assertEqual(result_vamp, HEALTH_STATE_HEALTHY)
def update_health_state(self):
"""
Updates the health state of this character.
Note: only call after that character's health *changes*
"""
self.health_state = DamageCalculator.calculate_new_health_state(
self.health_state, self.max_health, self.aggravated_health_damage,
self.superficial_health_damage, self.character.is_vampire)
def test_new_health_state_human_no_zombies(self):
# Humans that are dead, stay dead (... in combat anyway)
result_human = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_DEAD,
max_health=5,
old_aggravated_damage=5,
new_aggravated_damage=6,
new_superficial_damage=0,
is_vampire=False)
self.assertEqual(result_human, HEALTH_STATE_DEAD)
def test_new_health_state_human_injured_then_dead(self):
# Human injured, then splatted
result_human = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_INJURED,
max_health=5,
old_aggravated_damage=2,
new_aggravated_damage=5,
new_superficial_damage=0,
is_vampire=False)
self.assertEqual(result_human, HEALTH_STATE_DEAD)
def test_new_health_state_human_injured_then_impaired(self):
# Human injured, then takes damage and becomes impaired
result_human = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_INJURED,
max_health=5,
old_aggravated_damage=2,
new_aggravated_damage=2,
new_superficial_damage=3,
is_vampire=False)
self.assertEqual(result_human, HEALTH_STATE_IMPAIRED)
def test_new_health_state_vamp_impaired_still(self):
# Human injured, then takes damage and becomes impaired
result_vamp = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_IMPAIRED,
max_health=5,
old_aggravated_damage=2,
new_aggravated_damage=4,
new_superficial_damage=1,
is_vampire=True)
self.assertEqual(result_vamp, HEALTH_STATE_IMPAIRED)
def test_new_health_state_human_injured_diff_health(self):
# Test that the max health doesn't alter the result here.
result_human = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_HEALTHY,
max_health=7,
old_aggravated_damage=0,
new_aggravated_damage=2,
new_superficial_damage=3,
is_vampire=False)
self.assertEqual(result_human, HEALTH_STATE_INJURED)
def test_new_health_state_healthy_huaman(self):
# Test that with no damage done, the returned health state is healthy
result_human = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_HEALTHY,
max_health=5,
old_aggravated_damage=0,
new_aggravated_damage=0,
new_superficial_damage=0,
is_vampire=True)
self.assertEqual(result_human, HEALTH_STATE_HEALTHY)
def test_new_health_state_human_overkill(self):
# Human overkill
result_human = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_HEALTHY,
max_health=5,
old_aggravated_damage=0,
new_aggravated_damage=9999,
new_superficial_damage=0,
is_vampire=False)
self.assertEqual(result_human, HEALTH_STATE_DEAD)
def test_new_health_state_human_injured_mixed(self):
# Human injured, mixed damage types
result_human = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_HEALTHY,
max_health=5,
old_aggravated_damage=0,
new_aggravated_damage=1,
new_superficial_damage=2,
is_vampire=False)
self.assertEqual(result_human, HEALTH_STATE_INJURED)
def test_new_health_state_vamp_final_death_is_permanent(self):
# Vamps that have met the final death, stay dead
result_vamp = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_DEAD,
max_health=5,
old_aggravated_damage=5,
new_aggravated_damage=6,
new_superficial_damage=0,
is_vampire=True)
self.assertEqual(result_vamp, HEALTH_STATE_DEAD)
def test_new_health_state_vamp_torpor_recovery(self):
# vamps heal slowly in torpor but don't get better until they hit full HP
result_vamp = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_TORPOR,
max_health=5,
old_aggravated_damage=5,
new_aggravated_damage=4,
new_superficial_damage=0,
is_vampire=True)
self.assertEqual(result_vamp, HEALTH_STATE_TORPOR)
def test_new_health_state_vamp_injured_then_torpor(self):
# vampire injured, then put into torpor
result_vamp = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_INJURED,
max_health=5,
old_aggravated_damage=2,
new_aggravated_damage=5,
new_superficial_damage=0,
is_vampire=True)
self.assertEqual(result_vamp, HEALTH_STATE_TORPOR)
def test_new_health_state_human_injured_twice_superficial(self):
# Human Injured, then injured again superficially
result_human = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_INJURED,
max_health=7,
old_aggravated_damage=2,
new_aggravated_damage=2,
new_superficial_damage=3,
is_vampire=False)
self.assertEqual(result_human, HEALTH_STATE_INJURED)
def test_new_health_state_vamp_injured_twice_agg(self):
# vampire Injured, then injured again aggravated
result_vamp = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_INJURED,
max_health=7,
old_aggravated_damage=2,
new_aggravated_damage=3,
new_superficial_damage=3,
is_vampire=True)
self.assertEqual(result_vamp, HEALTH_STATE_INJURED)
def test_new_health_state_vamp_injured_superficial(self):
# vampire injured, superficial damage
result_vamp = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_HEALTHY,
max_health=5,
old_aggravated_damage=0,
new_aggravated_damage=0,
new_superficial_damage=1,
is_vampire=True)
self.assertEqual(result_vamp, HEALTH_STATE_INJURED)
def test_new_health_state_vamp_overkill(self):
# vampire overkill technically still sends them to torpor except under special circumstances not handled
# by the calculator (Storyteller's discretion)
result_vamp = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_HEALTHY,
max_health=5,
old_aggravated_damage=0,
new_aggravated_damage=9999,
new_superficial_damage=0,
is_vampire=True)
self.assertEqual(result_vamp, HEALTH_STATE_TORPOR)
def test_new_health_state_human_dead(self):
# Test the various ways that a human character takes damage
# Human hit for HP of Agg
result_human = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_HEALTHY,
max_health=5,
old_aggravated_damage=0,
new_aggravated_damage=5,
new_superficial_damage=0,
is_vampire=False)
self.assertEqual(result_human, HEALTH_STATE_DEAD)
def test_new_health_state_vamp_torpor(self):
# Test the various ways that a vampire character takes damage
# vampire hit for HP of Agg goes into torpor
result_vamp = DamageCalculator.calculate_new_health_state(
current_state=HEALTH_STATE_HEALTHY,
max_health=5,
old_aggravated_damage=0,
new_aggravated_damage=5,
new_superficial_damage=0,
is_vampire=True)
self.assertEqual(result_vamp, HEALTH_STATE_TORPOR)