def test_sharp__magic(self):
artifact = self.artifact_record.create_artifact(level=1,
power=Power(1, 1))
artifact.sharp(distribution=PowerDistribution(0.0, 1.0),
max_power=Power(3, 3))
artifact.sharp(distribution=PowerDistribution(0.0, 1.0),
max_power=Power(3, 3))
self.assertEqual(artifact.power, Power(1, 3))
def test_sharp__both(self):
artifact = self.artifact_record.create_artifact(level=1,
power=Power(1, 1))
artifact.sharp(distribution=PowerDistribution(0.5, 0.5),
max_power=Power(2, 2))
artifact.sharp(distribution=PowerDistribution(0.5, 0.5),
max_power=Power(2, 2))
self.assertEqual(artifact.power, Power(2, 2))
class ARTIFACT_POWER_TYPE(DjangoEnum):
distribution = Column()
records = ( ('MOST_MAGICAL', 0, u'магическая', PowerDistribution(0.1, 0.9)),
('MAGICAL', 1, u'ближе к магии', PowerDistribution(0.25, 0.75)),
('NEUTRAL', 2, u'равновесие', PowerDistribution(0.5, 0.5)),
('PHYSICAL', 3, u'ближе к физике', PowerDistribution(0.75, 0.25)),
('MOST_PHYSICAL', 4, u'физическая', PowerDistribution(0.9, 0.1)) )
def test_preference_rating__rarity(self):
self.assertTrue(
ArtifactPrototype._preference_rating(
relations.RARITY.NORMAL, Power(100, 100),
PowerDistribution(0.5, 0.5)) < ArtifactPrototype.
_preference_rating(relations.RARITY.RARE, Power(
100, 100), PowerDistribution(0.5, 0.5)) < ArtifactPrototype.
_preference_rating(relations.RARITY.EPIC, Power(100, 100),
PowerDistribution(0.5, 0.5)))
def test_better_artifact_power__on_low_levels(self):
median_power = Power.power_to_artifact(PowerDistribution(0.5, 0.5), 1)
self.assertEqual(median_power, Power(1, 1))
powers = set()
for i in range(100):
power = Power.better_artifact_power_randomized(PowerDistribution(0.5, 0.5), 1)
powers.add(power.magic)
powers.add(power.physic)
self.assertEqual(1 + c.ARTIFACT_BETTER_MIN_POWER_DELTA*2, len(powers))
def test_sharp__no_choices__and_force(self):
artifact = self.artifact_record.create_artifact(level=1,
power=Power(1, 1))
artifact.sharp(distribution=PowerDistribution(0.5, 0.5),
max_power=Power(1, 1),
force=True)
self.assertEqual(artifact.power.total(), 3)
def test_preference_rating(self):
self.assertEqual(
ArtifactPrototype._preference_rating(relations.RARITY.NORMAL,
Power(100, 100),
PowerDistribution(0.5, 0.5)),
100)
self.assertEqual(
ArtifactPrototype._preference_rating(relations.RARITY.NORMAL,
Power(100, 100),
PowerDistribution(0.2, 0.8)),
100)
self.assertEqual(
ArtifactPrototype._preference_rating(relations.RARITY.NORMAL,
Power(100, 100),
PowerDistribution(0.8, 0.2)),
100)
self.assertEqual(
ArtifactPrototype._preference_rating(relations.RARITY.NORMAL,
Power(100, 200),
PowerDistribution(0.5, 0.5)),
150)
self.assertEqual(
ArtifactPrototype._preference_rating(relations.RARITY.NORMAL,
Power(100, 200),
PowerDistribution(0.2, 0.8)),
180)
self.assertEqual(
ArtifactPrototype._preference_rating(relations.RARITY.NORMAL,
Power(100, 200),
PowerDistribution(0.8, 0.2)),
120)
self.assertEqual(
ArtifactPrototype._preference_rating(relations.RARITY.NORMAL,
Power(200, 100),
PowerDistribution(0.5, 0.5)),
150)
self.assertEqual(
ArtifactPrototype._preference_rating(relations.RARITY.NORMAL,
Power(200, 100),
PowerDistribution(0.2, 0.8)),
120)
self.assertEqual(
ArtifactPrototype._preference_rating(relations.RARITY.NORMAL,
Power(200, 100),
PowerDistribution(0.8, 0.2)),
180)
def test_make_better_than__magic(self):
artifact_1 = self.artifact_record.create_artifact(level=1,
power=Power(1, 1))
artifact_2 = self.artifact_record.create_artifact(level=1,
power=Power(3, 3))
artifact_1.make_better_than(artifact_2, PowerDistribution(0, 1.0))
self.assertTrue(artifact_1.power.magic > 3)
self.assertEqual(artifact_1.power.physic, 1)
class ARCHETYPE(DjangoEnum):
power_distribution = Column()
description = Column()
allowed_power_types = Column(no_index=True, unique=False)
records = ((u'MAGICAL', 0, u'маг', PowerDistribution(0.25, 0.75),
u'герой предпочитает магию грубой силе', [
ARTIFACT_POWER_TYPE.MOST_MAGICAL,
ARTIFACT_POWER_TYPE.MAGICAL, ARTIFACT_POWER_TYPE.NEUTRAL
]),
(u'NEUTRAL', 1, u'авантюрист', PowerDistribution(0.5, 0.5),
u'герой соблюдает баланс между мечом и магией', [
ARTIFACT_POWER_TYPE.MAGICAL, ARTIFACT_POWER_TYPE.NEUTRAL,
ARTIFACT_POWER_TYPE.PHYSICAL
]), (u'PHYSICAL', 2, u'воин', PowerDistribution(0.75, 0.25),
u'герой полагается на воинские умения', [
ARTIFACT_POWER_TYPE.NEUTRAL,
ARTIFACT_POWER_TYPE.PHYSICAL,
ARTIFACT_POWER_TYPE.MOST_PHYSICAL
]))
def test_make_better_than__already_better(self):
artifact_1 = self.artifact_record.create_artifact(level=1,
power=Power(2, 2))
artifact_2 = self.artifact_record.create_artifact(level=1,
power=Power(1, 1))
old_power = artifact_1.power.clone()
artifact_1.make_better_than(artifact_2, PowerDistribution(0.5, 0.5))
self.assertEqual(artifact_1.power, old_power)
def test_make_better_than__both(self):
artifact_1 = self.artifact_record.create_artifact(level=1,
power=Power(1, 1))
artifact_2 = self.artifact_record.create_artifact(level=1,
power=Power(
100, 100))
artifact_1.make_better_than(artifact_2, PowerDistribution(0.5, 0.5))
self.assertTrue(artifact_1.power.physic > 100
or artifact_1.power.magic > 100)
def test_sharp__no_choices(self):
artifact = self.artifact_record.create_artifact(level=1,
power=Power(1, 1))
old_integrity = artifact.integrity
old_max_integrity = artifact.max_integrity
artifact.sharp(distribution=PowerDistribution(0.5, 0.5),
max_power=Power(1, 1))
self.assertEqual(artifact.power, Power(1, 1))
self.assertEqual(old_integrity, artifact.integrity)
self.assertEqual(old_max_integrity, artifact.max_integrity)
def test_sharp__integrity_lost(self):
artifact = self.artifact_record.create_artifact(level=1,
power=Power(1, 1))
old_integrity = artifact.integrity
old_max_integrity = artifact.max_integrity
artifact.sharp(distribution=PowerDistribution(0.5, 0.5),
max_power=Power(3, 3))
self.assertTrue(old_integrity > artifact.integrity)
self.assertTrue(old_max_integrity > artifact.max_integrity)
self.assertEqual(artifact.integrity, artifact.max_integrity)
artifact.integrity /= 2
old_integrity = artifact.integrity
old_max_integrity = artifact.max_integrity
artifact.sharp(distribution=PowerDistribution(0.5, 0.5),
max_power=Power(3, 3))
self.assertEqual(old_integrity, artifact.integrity)
self.assertTrue(old_max_integrity > artifact.max_integrity)
def show_balance(self): # pylint: disable=R0914
tmp_time = [u'начало', u'8 часов', u'день', u'неделя', u'месяц', u'3 месяца', u'6 месяцев', u'1 год', u'2 года', u'3 года', u'4 года', u'5 лет', u'6 лет']
tmp_times = [0, 8, 24, 24*7, 24*30, 24*30*3, 24*30*6, 24*30*12, 24*30*12*2, 24*30*12*3, 24*30*12*4, 24*30*12*5, 24*30*12*6]
tmp_lvls = map(f.lvl_after_time, tmp_times)
# Всё, что ниже, должно зависеть от уровня, не от времени, т.к. время в данном случае не точный параметр, а анализ всё равно ориентируется на уровень.
exp_for_quest = f.experience_for_quest__real(c.QUEST_AREA_RADIUS)
tmp_exp_to_level = map(math.floor, map(f.exp_on_lvl, tmp_lvls))
tmp_exp_total = map(math.floor, map(f.total_exp_to_lvl, tmp_lvls))
tmp_quests_to_level = map(math.ceil, (exp/float(exp_for_quest) for exp in tmp_exp_to_level))
tmp_quests_total = map(math.ceil, (exp/float(exp_for_quest) for exp in tmp_exp_total))
dstr = PowerDistribution(0.5, 0.5)
tmp_hp = map(f.hp_on_lvl, tmp_lvls)
tmp_turns = map(f.turns_on_lvl, tmp_lvls)
tmp_turns_to_time = map(int, map(f.hours_to_turns, tmp_times))
tmp_expected_damage_to_hero_per_hit = map(f.expected_damage_to_hero_per_hit, tmp_lvls)
tmp_expected_damage_to_hero_per_hit_interval = [ (int(round(dmg*(1-c.DAMAGE_DELTA))), int(round(dmg*(1+c.DAMAGE_DELTA)))) for dmg in tmp_expected_damage_to_hero_per_hit]
tmp_mob_hp = map(f.mob_hp_to_lvl, tmp_lvls)
tmp_power = map(lambda lvl: Power.power_to_level(dstr, lvl), tmp_lvls)
tmp_expected_damage_to_mob_per_hit = map(f.expected_damage_to_mob_per_hit, tmp_lvls)
tmp_real_damage_to_mob_per_hit = map(lambda p: p.damage().total, tmp_power)
tmp_real_damage_to_mob_per_hit_interval = [ (int(round(dmg*(1-c.DAMAGE_DELTA))), int(round(dmg*(1+c.DAMAGE_DELTA)))) for dmg in tmp_real_damage_to_mob_per_hit]
tmp_power_per_slot = [Power.power_to_artifact(dstr, lvl) for lvl in tmp_lvls]
tmp_battles_at_lvl = map(math.floor, [x * c.BATTLES_PER_HOUR for x in map(f.time_on_lvl, tmp_lvls)])
tmp_total_battles = map(math.floor, [x * c.BATTLES_PER_HOUR for x in map(f.total_time_for_lvl, tmp_lvls)])
tmp_artifacts_per_battle = [c.ARTIFACTS_PER_BATTLE]* len(tmp_lvls)
tmp_artifacts_total = [c.ARTIFACTS_LOOT_PER_DAY * f.total_time_for_lvl(lvl-1)/24.0 for lvl in tmp_lvls]
tmp_gold_in_day = map(f.expected_gold_in_day, tmp_lvls)
tmp_total_gold_at_lvl = map(f.total_gold_at_lvl, tmp_lvls)
return self.template('balance/balance.html',
{'c': c,
'f': f ,
'exp_for_quest': exp_for_quest,
'average_path_length': c.QUEST_AREA_RADIUS,
'tmp_time': tmp_time,
'tmp_lvls': tmp_lvls,
'tmp_exp_to_level': tmp_exp_to_level,
'tmp_exp_total': tmp_exp_total,
'tmp_quests_to_level': tmp_quests_to_level,
'tmp_quests_total': tmp_quests_total,
'tmp_hp': tmp_hp,
'tmp_turns': tmp_turns,
'tmp_turns_to_time': tmp_turns_to_time,
'tmp_expected_damage_to_hero_per_hit': tmp_expected_damage_to_hero_per_hit,
'tmp_mob_hp': tmp_mob_hp,
'tmp_power': tmp_power,
'tmp_expected_damage_to_mob_per_hit': tmp_expected_damage_to_mob_per_hit,
'tmp_expected_damage_to_hero_per_hit_interval': tmp_expected_damage_to_hero_per_hit_interval,
'tmp_real_damage_to_mob_per_hit': tmp_real_damage_to_mob_per_hit,
'tmp_real_damage_to_mob_per_hit_interval': tmp_real_damage_to_mob_per_hit_interval,
'tmp_power_per_slot': tmp_power_per_slot,
'tmp_battles_at_lvl': tmp_battles_at_lvl,
'tmp_total_battles': tmp_total_battles,
'tmp_artifacts_total': tmp_artifacts_total,
'tmp_artifacts_per_battle': tmp_artifacts_per_battle,
# 'tmp_gold_at_lvl': tmp_gold_at_lvl,
'tmp_gold_in_day': tmp_gold_in_day,
'tmp_total_gold_at_lvl': tmp_total_gold_at_lvl
} )
def test_better_artifact_power(self):
self.check_better_artifact_power(
distribution=PowerDistribution(0.5, 0.5))
def test_better_artifact_power__physic(self):
self.check_better_artifact_power(
distribution=PowerDistribution(0.8, 0.2))
def test_better_artifact_power__magic(self):
self.check_better_artifact_power(
distribution=PowerDistribution(0.2, 0.8))
from the_tale.game.balance.power import Power, PowerDistribution
from the_tale.game.heroes.habilities import ABILITIES, ABILITY_AVAILABILITY, ABILITY_TYPE
class Messenger(object):
def add_message(self, *argv, **kwargs):
pass
MESSENGER = Messenger()
TEST_BATTLES_NUMBER = 40
LEVEL = 5
HERO_LEVELS = [5, 15, 25, 35, 45]
POWER_DISTRIBUTION = PowerDistribution(0.5, 0.5)
def process_battle(hero_1, hero_2):
hero_1_context = contexts.BattleContext()
hero_2_context = contexts.BattleContext()
while hero_1.health > 0 and hero_2.health > 0:
battle.make_turn(battle.Actor(hero_1, hero_1_context),
battle.Actor(hero_2, hero_2_context), MESSENGER)
return hero_1.health > 0
def get_battles_statistics(hero_1, hero_2):
