Exemple #1
0
 def test_effect(self):
     effect = effects.Huckster(buy_bonus_left=3, buy_bonus_right=3,
                               sell_bonus_left=2, sell_bonus_right=2)
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.BUY_PRICE, 12), 15)
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.BUY_PRICE, MODIFIERS.SELL_PRICE)), 11), 11)
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.SELL_PRICE, 13), 16)
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.BUY_PRICE, MODIFIERS.SELL_PRICE)), 11), 11)
 def test_effect(self):
     effect = effects.Huckster(buy_bonus_left=3, buy_bonus_right=3,
                               sell_bonus_left=2, sell_bonus_right=2)
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.BUY_PRICE, 12), 15)
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.BUY_PRICE, MODIFIERS.SELL_PRICE)), 11), 11)
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.SELL_PRICE, 13), 16)
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.BUY_PRICE, MODIFIERS.SELL_PRICE)), 11), 11)
    def test_effect(self):
        effect = effects.CompanionExpPerHeal(2)
        self.assertTrue(
            effect._check_attribute(MODIFIERS.COMPANION_EXP_PER_HEAL))
        self.assertFalse(
            effect._check_attribute(
                MODIFIERS.COMPANION_EXP_PER_HEAL_PROBABILITY))
        self.assertFalse(
            effect._check_attribute(
                MODIFIERS.random(
                    exclude=(MODIFIERS.COMPANION_EXP_PER_HEAL,
                             MODIFIERS.COMPANION_EXP_PER_HEAL_PROBABILITY))))

        self.assertEqual(
            effect._modify_attribute({}, MODIFIERS.COMPANION_EXP_PER_HEAL, 10),
            10)
        self.assertEqual(
            effect._modify_attribute(
                {}, MODIFIERS.COMPANION_EXP_PER_HEAL_PROBABILITY, 10), 20)
        self.assertEqual(
            effect._modify_attribute(
                {},
                MODIFIERS.random(
                    exclude=(MODIFIERS.COMPANION_EXP_PER_HEAL,
                             MODIFIERS.COMPANION_EXP_PER_HEAL_PROBABILITY)),
                11), 11)
    def test_effect(self):
        effect = effects.CompanionSayWisdom(3)

        self.assertTrue(effect._check_attribute(
            MODIFIERS.COMPANION_SAY_WISDOM))
        self.assertFalse(
            effect._check_attribute(
                MODIFIERS.COMPANION_SAY_WISDOM_PROBABILITY))
        self.assertFalse(
            effect._check_attribute(
                MODIFIERS.random(
                    exclude=(MODIFIERS.COMPANION_SAY_WISDOM,
                             MODIFIERS.COMPANION_SAY_WISDOM_PROBABILITY))))

        self.assertEqual(
            effect._modify_attribute({}, MODIFIERS.COMPANION_SAY_WISDOM, 10),
            10)
        self.assertEqual(
            effect._modify_attribute(
                {}, MODIFIERS.COMPANION_SAY_WISDOM_PROBABILITY, 10), 30)
        self.assertEqual(
            effect._modify_attribute(
                {},
                MODIFIERS.random(
                    exclude=(MODIFIERS.COMPANION_SAY_WISDOM,
                             MODIFIERS.COMPANION_SAY_WISDOM_PROBABILITY)), 11),
            11)
    def test_effect(self):
        effect = effects.CompanionEatCorpses(3)
        self.assertTrue(
            effect._check_attribute(MODIFIERS.COMPANION_EAT_CORPSES))
        self.assertFalse(
            effect._check_attribute(
                MODIFIERS.COMPANION_EAT_CORPSES_PROBABILITY))
        self.assertFalse(
            effect._check_attribute(
                MODIFIERS.random(
                    exclude=(MODIFIERS.COMPANION_EAT_CORPSES,
                             MODIFIERS.COMPANION_EAT_CORPSES_PROBABILITY))))

        self.assertEqual(
            effect._modify_attribute({}, MODIFIERS.COMPANION_EAT_CORPSES, 1),
            1)
        self.assertEqual(
            effect._modify_attribute(
                {}, MODIFIERS.COMPANION_EAT_CORPSES_PROBABILITY, 1), 3)
        self.assertEqual(
            effect._modify_attribute(
                {},
                MODIFIERS.random(
                    exclude=(MODIFIERS.COMPANION_EAT_CORPSES,
                             MODIFIERS.COMPANION_EAT_CORPSES_PROBABILITY)),
                11), 11)
    def test_effect(self):
        effect = effects.CompanionStealItem(3)
        self.assertTrue(effect._check_attribute(
            MODIFIERS.COMPANION_STEAL_ITEM))
        self.assertFalse(
            effect._check_attribute(MODIFIERS.COMPANION_STEAL_ITEM_MULTIPLIER))
        self.assertFalse(
            effect._check_attribute(
                MODIFIERS.random(exclude=(MODIFIERS.COMPANION_STEAL_ITEM,
                                          MODIFIERS.COMPANION_STEAL_ITEM))))

        self.assertEqual(
            effect._modify_attribute({}, MODIFIERS.COMPANION_STEAL_ITEM, 10),
            10)
        self.assertEqual(
            effect._modify_attribute({},
                                     MODIFIERS.COMPANION_STEAL_ITEM_MULTIPLIER,
                                     10), 30)
        self.assertEqual(
            effect._modify_attribute(
                {},
                MODIFIERS.random(
                    exclude=(MODIFIERS.COMPANION_STEAL_ITEM,
                             MODIFIERS.COMPANION_STEAL_ITEM_MULTIPLIER)), 11),
            11)
    def test_effect(self):
        effect = effects.CompanionRegenerate(2)

        self.assertTrue(effect._check_attribute(
            MODIFIERS.COMPANION_REGENERATE))
        self.assertFalse(
            effect._check_attribute(
                MODIFIERS.COMPANION_REGENERATE_PROBABILITY))
        self.assertFalse(
            effect._check_attribute(
                MODIFIERS.random(
                    exclude=(MODIFIERS.COMPANION_REGENERATE,
                             MODIFIERS.COMPANION_REGENERATE_PROBABILITY))))

        self.assertEqual(
            effect._modify_attribute({}, MODIFIERS.COMPANION_REGENERATE, 10),
            10)
        self.assertEqual(
            effect._modify_attribute(
                {}, MODIFIERS.COMPANION_REGENERATE_PROBABILITY, 10), 20)
        self.assertEqual(
            effect._modify_attribute(
                {},
                MODIFIERS.random(
                    exclude=(MODIFIERS.COMPANION_REGENERATE,
                             MODIFIERS.COMPANION_REGENERATE_PROBABILITY)), 11),
            11)
    def test_effect(self):
        effect = effects.CompanionDrinkArtifact(0.5)
        self.assertTrue(
            effect._check_attribute(MODIFIERS.COMPANION_DRINK_ARTIFACT))
        self.assertFalse(
            effect._check_attribute(
                MODIFIERS.COMPANION_DRINK_ARTIFACT_PROBABILITY))
        self.assertFalse(
            effect._check_attribute(
                MODIFIERS.random(
                    exclude=(MODIFIERS.COMPANION_DRINK_ARTIFACT,
                             MODIFIERS.COMPANION_DRINK_ARTIFACT_PROBABILITY))))

        self.assertEqual(
            effect._modify_attribute({}, MODIFIERS.COMPANION_DRINK_ARTIFACT,
                                     2), 2)
        self.assertEqual(
            effect._modify_attribute(
                {}, MODIFIERS.COMPANION_DRINK_ARTIFACT_PROBABILITY, 2), 1.0)
        self.assertEqual(
            effect._modify_attribute(
                {},
                MODIFIERS.random(exclude=(
                    MODIFIERS.COMPANION_DRINK_ARTIFACT,
                    MODIFIERS.COMPANION_DRINK_ARTIFACT_PROBABILITY,
                )), 11), 11)
    def test_effect(self):
        effect = effects.CompanionExorcist(0.5)

        self.assertTrue(effect._check_attribute(MODIFIERS.COMPANION_EXORCIST))
        self.assertFalse(
            effect._check_attribute(MODIFIERS.COMPANION_EXORCIST_PROBABILITY))
        self.assertFalse(
            effect._check_attribute(
                MODIFIERS.random(
                    exclude=(MODIFIERS.COMPANION_EXORCIST,
                             MODIFIERS.COMPANION_EXORCIST_PROBABILITY))))

        self.assertEqual(
            effect._modify_attribute({}, MODIFIERS.COMPANION_EXORCIST, 2), 2)
        self.assertEqual(
            effect._modify_attribute({},
                                     MODIFIERS.COMPANION_EXORCIST_PROBABILITY,
                                     2), 1.0)
        self.assertEqual(
            effect._modify_attribute(
                {},
                MODIFIERS.random(exclude=(
                    MODIFIERS.COMPANION_EXORCIST,
                    MODIFIERS.COMPANION_EXORCIST_PROBABILITY,
                )), 11), 11)
    def test_effect(self):
        effect = effects.CoherenceSpeed(0.8)
        self.assertEqual(
            effect._modify_attribute({}, MODIFIERS.COHERENCE_EXPERIENCE, 10),
            8)
        self.assertEqual(
            effect._modify_attribute({}, MODIFIERS.COHERENCE_EXPERIENCE, 11),
            8.8)
        self.assertEqual(
            effect._modify_attribute(
                {},
                MODIFIERS.random(exclude=(MODIFIERS.COHERENCE_EXPERIENCE, )),
                11), 11)

        effect = effects.CoherenceSpeed(1.2)
        self.assertEqual(
            effect._modify_attribute({}, MODIFIERS.COHERENCE_EXPERIENCE, 10),
            12)
        self.assertEqual(
            effect._modify_attribute({}, MODIFIERS.COHERENCE_EXPERIENCE, 11),
            13.2)
        self.assertEqual(
            effect._modify_attribute(
                {},
                MODIFIERS.random(exclude=(MODIFIERS.COHERENCE_EXPERIENCE, )),
                11), 11)
    def test_effect(self):
        effect = effects.CompanionEat(0.5)

        self.assertTrue(effect._check_attribute(MODIFIERS.COMPANION_MONEY_FOR_FOOD))
        self.assertFalse(effect._check_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_MONEY_FOR_FOOD,))))

        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_MONEY_FOR_FOOD, 2), 1.0)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.COMPANION_MONEY_FOR_FOOD,)), 11), 11)
Exemple #12
0
    def test_effect(self):
        effect = effects.CompanionEat(0.5)

        self.assertTrue(effect._check_attribute(MODIFIERS.COMPANION_MONEY_FOR_FOOD))
        self.assertFalse(effect._check_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_MONEY_FOR_FOOD,))))

        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_MONEY_FOR_FOOD, 2), 1.0)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.COMPANION_MONEY_FOR_FOOD,)), 11), 11)
Exemple #13
0
    def test_effect(self):
        effect = effects.CompanionStealItem(3)
        self.assertTrue(effect._check_attribute(MODIFIERS.COMPANION_STEAL_ITEM))
        self.assertFalse(effect._check_attribute(MODIFIERS.COMPANION_STEAL_ITEM_MULTIPLIER))
        self.assertFalse(effect._check_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_STEAL_ITEM, MODIFIERS.COMPANION_STEAL_ITEM))))

        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_STEAL_ITEM, 10), 10)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_STEAL_ITEM_MULTIPLIER, 10), 30)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.COMPANION_STEAL_ITEM, MODIFIERS.COMPANION_STEAL_ITEM_MULTIPLIER)), 11), 11)
Exemple #14
0
    def test_effect(self):
        effect = effects.CompanionExpPerHeal(2)
        self.assertTrue(effect._check_attribute(MODIFIERS.COMPANION_EXP_PER_HEAL))
        self.assertFalse(effect._check_attribute(MODIFIERS.COMPANION_EXP_PER_HEAL_PROBABILITY))
        self.assertFalse(effect._check_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_EXP_PER_HEAL, MODIFIERS.COMPANION_EXP_PER_HEAL_PROBABILITY))))

        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_EXP_PER_HEAL, 10), 10)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_EXP_PER_HEAL_PROBABILITY, 10), 20)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.COMPANION_EXP_PER_HEAL, MODIFIERS.COMPANION_EXP_PER_HEAL_PROBABILITY)), 11), 11)
Exemple #15
0
    def test_effect(self):
        effect = effects.CompanionDrinkArtifact(0.5)
        self.assertTrue(effect._check_attribute(MODIFIERS.COMPANION_DRINK_ARTIFACT))
        self.assertFalse(effect._check_attribute(MODIFIERS.COMPANION_DRINK_ARTIFACT_PROBABILITY))
        self.assertFalse(effect._check_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_DRINK_ARTIFACT,MODIFIERS.COMPANION_DRINK_ARTIFACT_PROBABILITY))))

        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_DRINK_ARTIFACT, 2), 2)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_DRINK_ARTIFACT_PROBABILITY, 2), 1.0)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.COMPANION_DRINK_ARTIFACT, MODIFIERS.COMPANION_DRINK_ARTIFACT_PROBABILITY,)), 11), 11)
Exemple #16
0
    def test_effect(self):
        effect = effects.CompanionEatCorpses(3)
        self.assertTrue(effect._check_attribute(MODIFIERS.COMPANION_EAT_CORPSES))
        self.assertFalse(effect._check_attribute(MODIFIERS.COMPANION_EAT_CORPSES_PROBABILITY))
        self.assertFalse(effect._check_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_EAT_CORPSES,MODIFIERS.COMPANION_EAT_CORPSES_PROBABILITY))))

        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_EAT_CORPSES, 1), 1)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_EAT_CORPSES_PROBABILITY, 1), 3)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.COMPANION_EAT_CORPSES, MODIFIERS.COMPANION_EAT_CORPSES_PROBABILITY)), 11), 11)
    def test_effect(self):
        effect = effects.QuestMoneyReward(0.5)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.QUEST_MONEY_REWARD, 10), 10.5)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.QUEST_MONEY_REWARD, 11), 11.5)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.QUEST_MONEY_REWARD,)), 11), 11)

        effect = effects.QuestMoneyReward(2.0)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.QUEST_MONEY_REWARD, 10), 12)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.QUEST_MONEY_REWARD, 11), 13)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.QUEST_MONEY_REWARD,)), 11), 11)
Exemple #18
0
    def test_effect(self):
        effect = effects.CoherenceSpeed(0.8)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COHERENCE_EXPERIENCE, 10), 8)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COHERENCE_EXPERIENCE, 11), 8.8)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.COHERENCE_EXPERIENCE,)), 11), 11)

        effect = effects.CoherenceSpeed(1.2)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COHERENCE_EXPERIENCE, 10), 12)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COHERENCE_EXPERIENCE, 11), 13.2)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.COHERENCE_EXPERIENCE,)), 11), 11)
Exemple #19
0
    def test_effect(self):
        effect = effects.QuestMoneyReward(0.5)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.QUEST_MONEY_REWARD, 10), 10.5)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.QUEST_MONEY_REWARD, 11), 11.5)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.QUEST_MONEY_REWARD,)), 11), 11)

        effect = effects.QuestMoneyReward(2.0)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.QUEST_MONEY_REWARD, 10), 12)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.QUEST_MONEY_REWARD, 11), 13)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.QUEST_MONEY_REWARD,)), 11), 11)
Exemple #20
0
    def test_effect(self):
        effect = effects.CompanionExorcist(0.5)

        self.assertTrue(effect._check_attribute(MODIFIERS.COMPANION_EXORCIST))
        self.assertFalse(effect._check_attribute(MODIFIERS.COMPANION_EXORCIST_PROBABILITY))
        self.assertFalse(effect._check_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_EXORCIST, MODIFIERS.COMPANION_EXORCIST_PROBABILITY))))

        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_EXORCIST, 2), 2)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_EXORCIST_PROBABILITY, 2), 1.0)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.COMPANION_EXORCIST, MODIFIERS.COMPANION_EXORCIST_PROBABILITY,)), 11), 11)
Exemple #21
0
    def test_effect(self):
        effect = effects.CompanionSayWisdom(3)

        self.assertTrue(effect._check_attribute(MODIFIERS.COMPANION_SAY_WISDOM))
        self.assertFalse(effect._check_attribute(MODIFIERS.COMPANION_SAY_WISDOM_PROBABILITY))
        self.assertFalse(effect._check_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_SAY_WISDOM, MODIFIERS.COMPANION_SAY_WISDOM_PROBABILITY))))

        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_SAY_WISDOM, 10), 10)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_SAY_WISDOM_PROBABILITY, 10), 30)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.COMPANION_SAY_WISDOM, MODIFIERS.COMPANION_SAY_WISDOM_PROBABILITY)), 11), 11)
Exemple #22
0
    def test_effect(self):
        effect = effects.CompanionRegenerate(2)

        self.assertTrue(effect._check_attribute(MODIFIERS.COMPANION_REGENERATE))
        self.assertFalse(effect._check_attribute(MODIFIERS.COMPANION_REGENERATE_PROBABILITY))
        self.assertFalse(effect._check_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_REGENERATE, MODIFIERS.COMPANION_REGENERATE_PROBABILITY))))

        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_REGENERATE, 10), 10)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_REGENERATE_PROBABILITY, 10), 20)
        self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.COMPANION_REGENERATE, MODIFIERS.COMPANION_REGENERATE_PROBABILITY)), 11), 11)
    def test_coherence(self):
        self.assertEqual(companions.COHERENCE().modify_attribute(MODIFIERS.COMPANION_MAX_COHERENCE, 0), 20)
        self.assertEqual(companions.COHERENCE().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_MAX_COHERENCE,)), 1), 1)

        self.assertEqual(self.hero.companion_max_coherence, 20) # coherence lvl 1 — default hero ability
        self.hero.abilities.add(companions.COHERENCE.get_id(), 3)
        self.assertEqual(self.hero.companion_max_coherence, 60)
 def test_effect(self):
     effect = effects.ChangeHabits(habit_type=game_relations.HABIT_TYPE.HONOR,
                                   habit_sources=(heroes_relations.HABIT_CHANGE_SOURCE.COMPANION_HONOR_NEUTRAL_1,
                                                  heroes_relations.HABIT_CHANGE_SOURCE.COMPANION_HONOR_NEUTRAL_2))
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.HABITS_SOURCES, set()), set((heroes_relations.HABIT_CHANGE_SOURCE.COMPANION_HONOR_NEUTRAL_1,
                                                                                      heroes_relations.HABIT_CHANGE_SOURCE.COMPANION_HONOR_NEUTRAL_2)))
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.HABITS_SOURCES,)), set()), set())
    def test_sacredness(self):
        self.assertEqual(companions.SACREDNESS().modify_attribute(MODIFIERS.COMPANION_UNUSUAL_COHERENCE_SPEED, 1), 1.2)
        self.assertEqual(companions.SACREDNESS().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_UNUSUAL_COHERENCE_SPEED,)), 1), 1)

        self.assertEqual(self.hero.companion_unusual_coherence_speed, 1)
        self.hero.abilities.add(companions.SACREDNESS.get_id(), 3)
        self.assertEqual(self.hero.companion_unusual_coherence_speed, 1.6)
    def test_service(self):
        self.assertEqual(companions.SERVICE().modify_attribute(MODIFIERS.COMPANION_CONSTRUCT_COHERENCE_SPEED, 1), 1.2)
        self.assertEqual(companions.SERVICE().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_CONSTRUCT_COHERENCE_SPEED,)), 1), 1)

        self.assertEqual(self.hero.companion_construct_coherence_speed, 1)
        self.hero.abilities.add(companions.SERVICE.get_id(), 3)
        self.assertEqual(self.hero.companion_construct_coherence_speed, 1.6)
    def test_sociability(self):
        self.assertEqual(companions.SOCIABILITY().modify_attribute(MODIFIERS.COMPANION_LIVING_COHERENCE_SPEED, 1), 1.2)
        self.assertEqual(companions.SOCIABILITY().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_LIVING_COHERENCE_SPEED,)), 1), 1)

        self.assertEqual(self.hero.companion_living_coherence_speed, 1)
        self.hero.abilities.add(companions.SOCIABILITY.get_id(), 3)
        self.assertEqual(self.hero.companion_living_coherence_speed, 1.6)
Exemple #28
0
 def test_effect(self):
     effect = effects.ChangeHabits(habit_type=game_relations.HABIT_TYPE.HONOR,
                                   habit_sources=(heroes_relations.HABIT_CHANGE_SOURCE.COMPANION_HONOR_NEUTRAL_1,
                                                  heroes_relations.HABIT_CHANGE_SOURCE.COMPANION_HONOR_NEUTRAL_2))
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.HABITS_SOURCES, set()), set((heroes_relations.HABIT_CHANGE_SOURCE.COMPANION_HONOR_NEUTRAL_1,
                                                                                      heroes_relations.HABIT_CHANGE_SOURCE.COMPANION_HONOR_NEUTRAL_2)))
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.HABITS_SOURCES,)), set()), set())
    def test_thoughtful(self):
        self.assertEqual(companions.THOUGHTFUL().modify_attribute(MODIFIERS.COMPANION_MAX_HEALTH, 1.0), 1.1)
        self.assertEqual(companions.THOUGHTFUL().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_MAX_HEALTH,)), 1), 1)

        self.assertEqual(self.hero.companion_max_health_multiplier, 1)
        self.hero.abilities.add(companions.THOUGHTFUL.get_id(), 3)
        self.assertEqual(self.hero.companion_max_health_multiplier, 1.3)
    def test_coherence(self):
        self.assertEqual(companions.COHERENCE().modify_attribute(MODIFIERS.COMPANION_MAX_COHERENCE, 0), 20)
        self.assertEqual(companions.COHERENCE().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_MAX_COHERENCE,)), 1), 1)

        self.assertEqual(self.hero.companion_max_coherence, 20) # coherence lvl 1 — default hero ability
        self.hero.abilities.add(companions.COHERENCE.get_id(), 3)
        self.assertEqual(self.hero.companion_max_coherence, 60)
    def test_healing(self):
        self.assertEqual(companions.HEALING().modify_attribute(MODIFIERS.COMPANION_LIVING_HEAL, 0), 0.0462962962962963)
        self.assertEqual(companions.HEALING().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_LIVING_HEAL,)), 0), 0)

        self.assertEqual(self.hero.companion_living_heal_probability, 0)
        self.hero.abilities.add(companions.HEALING.get_id(), 3)
        self.assertEqual(self.hero.companion_living_heal_probability, 0.1388888888888889)
    def test_thoughtful(self):
        self.assertEqual(companions.THOUGHTFUL().modify_attribute(MODIFIERS.COMPANION_MAX_HEALTH, 1.0), 1.1)
        self.assertEqual(companions.THOUGHTFUL().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_MAX_HEALTH,)), 1), 1)

        self.assertEqual(self.hero.companion_max_health_multiplier, 1)
        self.hero.abilities.add(companions.THOUGHTFUL.get_id(), 3)
        self.assertEqual(self.hero.companion_max_health_multiplier, 1.3)
    def test_witchcraft(self):
        self.assertEqual(companions.WITCHCRAFT().modify_attribute(MODIFIERS.COMPANION_UNUSUAL_HEAL, 0), 0.0462962962962963)
        self.assertEqual(companions.WITCHCRAFT().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_UNUSUAL_HEAL,)), 0), 0)

        self.assertEqual(self.hero.companion_unusual_heal_probability, 0)
        self.hero.abilities.add(companions.WITCHCRAFT.get_id(), 3)
        self.assertEqual(self.hero.companion_unusual_heal_probability, 0.1388888888888889)
    def test_mage_mechanincs(self):
        self.assertEqual(companions.MAGE_MECHANICS().modify_attribute(MODIFIERS.COMPANION_CONSTRUCT_HEAL, 0), 0.0462962962962963)
        self.assertEqual(companions.MAGE_MECHANICS().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_CONSTRUCT_HEAL,)), 0), 0)

        self.assertEqual(self.hero.companion_construct_heal_probability, 0)
        self.hero.abilities.add(companions.MAGE_MECHANICS.get_id(), 3)
        self.assertEqual(self.hero.companion_construct_heal_probability, 0.1388888888888889)
 def test_effect(self):
     effect = effects.PoliticsPower(3)
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.POWER, 11),
                      14.0)
     self.assertEqual(
         effect._modify_attribute(
             {}, MODIFIERS.random(exclude=(MODIFIERS.POWER, )), 11), 11)
 def test_effect(self):
     effect = effects.CompanionSpareParts()
     self.assertTrue(
         effect._check_attribute(MODIFIERS.COMPANION_SPARE_PARTS))
     self.assertFalse(
         effect._check_attribute(
             MODIFIERS.random(exclude=(MODIFIERS.COMPANION_SPARE_PARTS, ))))
    def test_economic(self):
        self.assertEqual(companions.ECONOMIC().modify_attribute(MODIFIERS.COMPANION_ABILITIES_LEVELS, {}),
                        {companions_abilities_relations.METATYPE.MONEY: 1})
        self.assertEqual(companions.ECONOMIC().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_ABILITIES_LEVELS,)), {}), {})

        self.assertEqual(self.hero.companion_abilities_levels, {})
        self.hero.abilities.add(companions.ECONOMIC.get_id(), 3)
        self.assertEqual(self.hero.companion_abilities_levels, {companions_abilities_relations.METATYPE.MONEY: 3})
 def test_effect(self):
     effect = effects.CompanionFly(0.1)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.COMPANION_FLYER, 0), 0.1)
     self.assertEqual(
         effect._modify_attribute(
             {}, MODIFIERS.random(exclude=(MODIFIERS.COMPANION_FLYER, )),
             11), 11)
    def test_improviser(self):
        self.assertEqual(companions.IMPROVISER().modify_attribute(MODIFIERS.COMPANION_ABILITIES_LEVELS, {}),
                        {companions_abilities_relations.METATYPE.OTHER: 1})
        self.assertEqual(companions.IMPROVISER().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_ABILITIES_LEVELS,)), {}), {})

        self.assertEqual(self.hero.companion_abilities_levels, {})
        self.hero.abilities.add(companions.IMPROVISER.get_id(), 3)
        self.assertEqual(self.hero.companion_abilities_levels, {companions_abilities_relations.METATYPE.OTHER: 3})
 def test_effect(self):
     effect = effects.EtherealMagnet(0.1)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.MIGHT_CRIT_CHANCE, 0), 0.1)
     self.assertEqual(
         effect._modify_attribute(
             {}, MODIFIERS.random(exclude=(MODIFIERS.MIGHT_CRIT_CHANCE, )),
             11), 11)
 def test_effect(self):
     effect = effects.Initiative(2)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.INITIATIVE, 10), 20)
     self.assertEqual(
         effect._modify_attribute(
             {}, MODIFIERS.random(exclude=(MODIFIERS.INITIATIVE, )), 11),
         11)
    def test_comrade(self):
        self.assertEqual(companions.COMRADE().modify_attribute(MODIFIERS.COMPANION_ABILITIES_LEVELS, {}),
                        {companions_abilities_relations.METATYPE.BATTLE: 1})
        self.assertEqual(companions.COMRADE().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_ABILITIES_LEVELS,)), {}), {})

        self.assertEqual(self.hero.companion_abilities_levels, {})
        self.hero.abilities.add(companions.COMRADE.get_id(), 3)
        self.assertEqual(self.hero.companion_abilities_levels, {companions_abilities_relations.METATYPE.BATTLE: 3})
    def test_comrade(self):
        self.assertEqual(companions.COMRADE().modify_attribute(MODIFIERS.COMPANION_ABILITIES_LEVELS, {}),
                        {companions_abilities_relations.METATYPE.BATTLE: 1})
        self.assertEqual(companions.COMRADE().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_ABILITIES_LEVELS,)), {}), {})

        self.assertEqual(self.hero.companion_abilities_levels, {})
        self.hero.abilities.add(companions.COMRADE.get_id(), 3)
        self.assertEqual(self.hero.companion_abilities_levels, {companions_abilities_relations.METATYPE.BATTLE: 3})
    def test_improviser(self):
        self.assertEqual(companions.IMPROVISER().modify_attribute(MODIFIERS.COMPANION_ABILITIES_LEVELS, {}),
                        {companions_abilities_relations.METATYPE.OTHER: 1})
        self.assertEqual(companions.IMPROVISER().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_ABILITIES_LEVELS,)), {}), {})

        self.assertEqual(self.hero.companion_abilities_levels, {})
        self.hero.abilities.add(companions.IMPROVISER.get_id(), 3)
        self.assertEqual(self.hero.companion_abilities_levels, {companions_abilities_relations.METATYPE.OTHER: 3})
    def test_economic(self):
        self.assertEqual(companions.ECONOMIC().modify_attribute(MODIFIERS.COMPANION_ABILITIES_LEVELS, {}),
                        {companions_abilities_relations.METATYPE.MONEY: 1})
        self.assertEqual(companions.ECONOMIC().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_ABILITIES_LEVELS,)), {}), {})

        self.assertEqual(self.hero.companion_abilities_levels, {})
        self.hero.abilities.add(companions.ECONOMIC.get_id(), 3)
        self.assertEqual(self.hero.companion_abilities_levels, {companions_abilities_relations.METATYPE.MONEY: 3})
 def test_effect(self):
     effect = effects.LootProbability(2)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.LOOT_PROBABILITY, 10), 20)
     self.assertEqual(
         effect._modify_attribute(
             {}, MODIFIERS.random(exclude=(MODIFIERS.LOOT_PROBABILITY, )),
             11), 11)
 def test_effect(self):
     effect = effects.BattleProbability(1.5)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.BATTLES_PER_TURN, 10), 11.5)
     self.assertEqual(
         effect._modify_attribute(
             {}, MODIFIERS.random(exclude=(MODIFIERS.BATTLES_PER_TURN, )),
             11), 11)
 def test_effect(self):
     effect = effects.IDLELenght(3)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.IDLE_LENGTH, 12), 36)
     self.assertEqual(
         effect._modify_attribute(
             {}, MODIFIERS.random(exclude=(MODIFIERS.IDLE_LENGTH, )), 11),
         11)
 def test_effect(self):
     effect = effects.CompanionDamage(3)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.COMPANION_DAMAGE, 10), 13)
     self.assertEqual(
         effect._modify_attribute(
             {}, MODIFIERS.random(exclude=(MODIFIERS.COMPANION_DAMAGE, )),
             11), 11)
 def test_effect(self):
     effect = effects.Unsociable(0.1)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.COMPANION_LEAVE_IN_PLACE,
                                  0), 0.1)
     self.assertEqual(
         effect._modify_attribute(
             {},
             MODIFIERS.random(
                 exclude=(MODIFIERS.COMPANION_LEAVE_IN_PLACE, )), 11), 11)
 def test_effect(self):
     effect = effects.MaxBagSize(666)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.MAX_BAG_SIZE, 10), 676)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.MAX_BAG_SIZE, 11), 677)
     self.assertEqual(
         effect._modify_attribute(
             {}, MODIFIERS.random(exclude=(MODIFIERS.MAX_BAG_SIZE, )), 11),
         11)
 def test_effect(self):
     effect = effects.DoubleEnergyRegeneration(0.1)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.DOUBLE_ENERGY_REGENERATION,
                                  0), 0.1)
     self.assertEqual(
         effect._modify_attribute(
             {},
             MODIFIERS.random(
                 exclude=(MODIFIERS.DOUBLE_ENERGY_REGENERATION, )), 11), 11)
 def test_effect(self):
     effect = effects.PhysicDamageBonus(2)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.MAGIC_DAMAGE, 10), 10)
     self.assertEqual(
         effect._modify_attribute({}, MODIFIERS.PHYSIC_DAMAGE, 10), 20)
     self.assertEqual(
         effect._modify_attribute(
             {}, MODIFIERS.random(exclude=(MODIFIERS.PHYSIC_DAMAGE, )), 11),
         11)
Exemple #54
0
    def test_mage_mechanincs(self):
        self.assertEqual(companions.MAGE_MECHANICS().modify_attribute(MODIFIERS.COMPANION_CONSTRUCT_HEAL, 0), 0.0462962962962963)
        self.assertEqual(companions.MAGE_MECHANICS().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_CONSTRUCT_HEAL,)), 0), 0)

        companion_record = next(companions_storage.companions.enabled_companions())
        self.hero.set_companion(companions_logic.create_companion(companion_record))

        with mock.patch('the_tale.game.companions.objects.CompanionRecord.type', game_relations.BEING_TYPE.MECHANICAL):
            self.assertEqual(self.hero.companion_heal_probability, 0)
            self.hero.abilities.add(companions.MAGE_MECHANICS.get_id(), 3)
            self.assertEqual(self.hero.companion_heal_probability, 0.1388888888888889)
Exemple #55
0
    def test_service(self):
        self.assertEqual(companions.SERVICE().modify_attribute(MODIFIERS.COMPANION_CONSTRUCT_COHERENCE_SPEED, 1), 1.2)
        self.assertEqual(companions.SERVICE().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_CONSTRUCT_COHERENCE_SPEED,)), 1), 1)

        companion_record = next(companions_storage.companions.enabled_companions())
        self.hero.set_companion(companions_logic.create_companion(companion_record))

        with mock.patch('the_tale.game.companions.objects.CompanionRecord.type', game_relations.BEING_TYPE.MECHANICAL):
            self.assertEqual(self.hero.companion_coherence_speed, 1)
            self.hero.abilities.add(companions.SERVICE.get_id(), 3)
            self.assertEqual(self.hero.companion_coherence_speed, 1.6)
Exemple #56
0
    def test_sacredness(self):
        self.assertEqual(companions.SACREDNESS().modify_attribute(MODIFIERS.COMPANION_UNUSUAL_COHERENCE_SPEED, 1), 1.2)
        self.assertEqual(companions.SACREDNESS().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_UNUSUAL_COHERENCE_SPEED,)), 1), 1)

        companion_record = next(companions_storage.companions.enabled_companions())
        self.hero.set_companion(companions_logic.create_companion(companion_record))

        with mock.patch('the_tale.game.companions.objects.CompanionRecord.type', game_relations.BEING_TYPE.SUPERNATURAL):
            self.assertEqual(self.hero.companion_coherence_speed, 1)
            self.hero.abilities.add(companions.SACREDNESS.get_id(), 3)
            self.assertEqual(self.hero.companion_coherence_speed, 1.6)
Exemple #57
0
    def test_witchcraft(self):
        self.assertEqual(companions.WITCHCRAFT().modify_attribute(MODIFIERS.COMPANION_UNUSUAL_HEAL, 0), 0.0462962962962963)
        self.assertEqual(companions.WITCHCRAFT().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_UNUSUAL_HEAL,)), 0), 0)

        companion_record = next(companions_storage.companions.enabled_companions())
        self.hero.set_companion(companions_logic.create_companion(companion_record))

        with mock.patch('the_tale.game.companions.objects.CompanionRecord.type', game_relations.BEING_TYPE.SUPERNATURAL):
            self.assertEqual(self.hero.companion_heal_probability, 0)
            self.hero.abilities.add(companions.WITCHCRAFT.get_id(), 3)
            self.assertEqual(self.hero.companion_heal_probability, 0.1388888888888889)
    def test_sociability(self):
        self.assertEqual(companions.SOCIABILITY().modify_attribute(MODIFIERS.COMPANION_LIVING_COHERENCE_SPEED, 1), 1.2)
        self.assertEqual(companions.SOCIABILITY().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_LIVING_COHERENCE_SPEED,)), 1), 1)

        companion_record = companions_storage.companions.enabled_companions().next()
        self.hero.set_companion(companions_logic.create_companion(companion_record))

        with mock.patch('the_tale.game.companions.objects.CompanionRecord.type', game_relations.BEING_TYPE.ANIMAL):
            self.assertEqual(self.hero.companion_coherence_speed, 1)
            self.hero.abilities.add(companions.SOCIABILITY.get_id(), 3)
            self.assertEqual(self.hero.companion_coherence_speed, 1.6)
    def test_healing(self):
        self.assertEqual(companions.HEALING().modify_attribute(MODIFIERS.COMPANION_LIVING_HEAL, 0), 0.0462962962962963)
        self.assertEqual(companions.HEALING().modify_attribute(MODIFIERS.random(exclude=(MODIFIERS.COMPANION_LIVING_HEAL,)), 0), 0)

        companion_record = companions_storage.companions.enabled_companions().next()
        self.hero.set_companion(companions_logic.create_companion(companion_record))

        with mock.patch('the_tale.game.companions.objects.CompanionRecord.type', game_relations.BEING_TYPE.ANIMAL):
            self.assertEqual(self.hero.companion_heal_probability, 0)
            self.hero.abilities.add(companions.HEALING.get_id(), 3)
            self.assertEqual(self.hero.companion_heal_probability, 0.1388888888888889)
Exemple #60
0
 def test_effect(self):
     effect = effects.Unsociable(0.1)
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.COMPANION_LEAVE_IN_PLACE, 0), 0.1)
     self.assertEqual(effect._modify_attribute({}, MODIFIERS.random(exclude=(MODIFIERS.COMPANION_LEAVE_IN_PLACE,)), 11), 11)