Beispiel #1
0
    def setUp(self):
        super(BattlePvE1x1ActionTest, self).setUp()

        create_test_map()

        account = self.accounts_factory.create_account()

        self.storage = LogicStorage()
        self.storage.load_account_data(account)
        self.hero = self.storage.accounts_to_heroes[account.id]

        self.hero.level = 6
        self.hero.health = self.hero.max_health

        # do half of tests with companion
        if random.random() < 0.5:
            companion_record = next(
                companions_storage.companions.enabled_companions())
            companion = companions_logic.create_companion(companion_record)
            self.hero.set_companion(companion)
            self.hero.companion.health = 1

        self.action_idl = self.hero.actions.current_action

        with mock.patch(
                'the_tale.game.balance.constants.KILL_BEFORE_BATTLE_PROBABILITY',
                0):
            self.action_battle = ActionBattlePvE1x1Prototype.create(
                hero=self.hero,
                mob=mobs_storage.create_mob_for_hero(self.hero))
Beispiel #2
0
    def test_load_account_data(self):
        self.assertEqual(len(self.storage.heroes), 2)
        self.assertEqual(len(self.storage.accounts_to_heroes), 2)
        self.assertEqual(
            self.storage.bundles_to_accounts, {
                self.hero_1.actions.current_action.bundle_id:
                set([self.account_1.id]),
                self.hero_2.actions.current_action.bundle_id:
                set([self.account_2.id])
            })

        action_regenerate = actions_prototypes.ActionRegenerateEnergyPrototype.create(
            hero=self.hero_1)

        self.assertEqual(self.action_idl_1.storage, self.storage)
        self.assertEqual(action_regenerate.storage, self.storage)

        storage = LogicStorage()
        storage.load_account_data(self.account_1)
        storage.load_account_data(self.account_2)
        self.assertEqual(len(storage.heroes), 2)
        self.assertEqual(len(storage.accounts_to_heroes), 2)
        self.assertEqual(
            storage.bundles_to_accounts, {
                self.hero_1.actions.current_action.bundle_id:
                set([self.account_1.id]),
                self.hero_2.actions.current_action.bundle_id:
                set([self.account_2.id])
            })
Beispiel #3
0
    def test_load_account_data_with_meta_action(self):
        bundle_id = 666

        meta_action_battle = meta_actions.ArenaPvP1x1.create(
            self.storage, self.hero_1, self.hero_2)

        proxy_action_1 = actions_prototypes.ActionMetaProxyPrototype.create(
            hero=self.hero_1,
            _bundle_id=bundle_id,
            meta_action=meta_action_battle)
        proxy_action_2 = actions_prototypes.ActionMetaProxyPrototype.create(
            hero=self.hero_2,
            _bundle_id=bundle_id,
            meta_action=meta_action_battle)

        self.assertEqual(len(self.storage.meta_actions), 1)
        self.assertEqual(len(self.storage.meta_actions_to_actions), 1)
        self.assertEqual(
            self.storage.meta_actions_to_actions[meta_action_battle.uid],
            set([
                LogicStorage.get_action_uid(proxy_action_1),
                LogicStorage.get_action_uid(proxy_action_2)
            ]))

        self.storage.save_changed_data()

        self.assertIs(self.hero_1.actions.current_action.meta_action,
                      self.hero_2.actions.current_action.meta_action)
        self.assertIs(self.hero_1.actions.current_action.saved_meta_action,
                      self.hero_2.actions.current_action.saved_meta_action)

        storage = LogicStorage()
        storage.load_account_data(self.account_1)
        storage.load_account_data(self.account_2)

        self.assertEqual(len(storage.meta_actions), 1)
        self.assertEqual(len(storage.meta_actions_to_actions), 1)
        self.assertEqual(
            storage.meta_actions_to_actions[meta_action_battle.uid],
            set([
                LogicStorage.get_action_uid(proxy_action_1),
                LogicStorage.get_action_uid(proxy_action_2)
            ]))

        self.assertEqual(
            storage.bundles_to_accounts, {
                self.hero_1.actions.current_action.bundle_id:
                set([self.account_1.id, self.account_2.id])
            })

        hero_1 = storage.accounts_to_heroes[self.account_1.id]
        hero_2 = storage.accounts_to_heroes[self.account_2.id]

        self.assertIs(hero_1.actions.current_action.meta_action,
                      hero_2.actions.current_action.meta_action)
        self.assertIsNot(hero_1.actions.current_action.saved_meta_action,
                         hero_2.actions.current_action.saved_meta_action)
        self.assertEqual(
            hero_1.actions.current_action.saved_meta_action.serialize(),
            hero_2.actions.current_action.saved_meta_action.serialize())
    def setUp(self):
        super(RepairBuildingTests, self).setUp()

        self.place_1, self.place_2, self.place_3 = create_test_map()

        self.account_1 = self.accounts_factory.create_account()
        self.account_2 = self.accounts_factory.create_account(is_fast=True)

        self.storage = LogicStorage()
        self.storage.load_account_data(self.account_1)
        self.storage.load_account_data(self.account_2)

        self.hero = self.storage.accounts_to_heroes[self.account_1.id]

        self.card = self.CARD()

        environment.deinitialize()
        environment.initialize()

        self.highlevel = environment.workers.highlevel
        self.highlevel.process_initialize(0, 'highlevel')

        self.building_1 = places_logic.create_building(person=self.place_1.persons[0], utg_name=names.generator().get_test_name('building-1-name'))
        self.building_2 = places_logic.create_building(person=self.place_2.persons[0], utg_name=names.generator().get_test_name('building-1-name'))

        self.building_1.amortize(c.TURNS_IN_HOUR*24)
        self.building_2.amortize(c.TURNS_IN_HOUR*24)
Beispiel #5
0
    def test_save_bundle_data(self):

        storage = LogicStorage()

        storage.bundles_to_accounts[555] = set([1, 2])
        storage.bundles_to_accounts[666] = set([3, 7, 9])
        storage.bundles_to_accounts[777] = set([4, 5])

        storage.accounts_to_heroes = {
            1: mock.Mock(id=1),
            2: mock.Mock(id=2),
            3: mock.Mock(id=3),
            4: mock.Mock(id=4),
            5: mock.Mock(id=5),
            7: mock.Mock(id=7),
            9: mock.Mock(id=9)
        }

        with mock.patch(
                'the_tale.game.logic_storage.LogicStorage._save_hero_data'
        ) as _save_hero_data:
            with mock.patch(
                    'the_tale.game.logic_storage.LogicStorage.process_cache_queue'
            ) as process_cache_queue:
                storage.save_bundle_data(666)

        self.assertEqual(_save_hero_data.call_count, 3)
        self.assertEqual(storage.cache_queue, set([3, 7, 9]))
        self.assertEqual(process_cache_queue.call_count, 1)

        self.assertEqual(
            set(call[0][0] for call in _save_hero_data.call_args_list),
            set([3, 7, 9]))
Beispiel #6
0
    def setUp(self):
        super(UseCardTaskTests, self).setUp()

        self.place_1, self.place_2, self.place_3 = create_test_map()

        self.account = self.accounts_factory.create_account()
        self.storage = LogicStorage()
        self.storage.load_account_data(self.account)
        self.hero = self.storage.accounts_to_heroes[self.account.id]

        self.building_1 = BuildingPrototype.create(
            person=self.place_1.persons[0],
            utg_name=names.generator().get_test_name('building-1-name'))

        environment.deinitialize()
        environment.initialize()

        self.highlevel = environment.workers.highlevel
        self.highlevel.process_initialize(0, 'highlevel')

        self.task_data = {
            'place_id': self.place_1.id,
            'person_id': self.place_1.persons[0].id,
            'building_id': self.building_1.id
        }
Beispiel #7
0
    def setUp(self):
        super(QuestsTestBase, self).setUp()
        self.p1, self.p2, self.p3 = create_test_map()

        # add more persons, to lower conflicts
        places_logic.add_person_to_place(self.p1)
        places_logic.add_person_to_place(self.p1)
        places_logic.add_person_to_place(self.p2)
        places_logic.add_person_to_place(self.p2)
        places_logic.add_person_to_place(self.p3)
        places_logic.add_person_to_place(self.p3)

        persons_logic.sync_social_connections()

        result, account_id, bundle_id = register_user('test_user')

        self.storage = LogicStorage()
        self.storage.load_account_data(AccountPrototype.get_by_id(account_id))
        self.hero = self.storage.accounts_to_heroes[account_id]
        self.action_idl = self.hero.actions.current_action

        self.hero.money += 1
        self.hero.preferences.set_mob(mobs_storage.all()[0])
        self.hero.preferences.set_place(self.p1)
        self.hero.preferences.set_friend(self.p1.persons[0])
        self.hero.preferences.set_enemy(self.p2.persons[0])
        self.hero.preferences.set_equipment_slot(EQUIPMENT_SLOT.PLATE)
        self.hero.position.set_place(self.p3)
        heroes_logic.save_hero(self.hero)

        self.p2.set_modifier(places_modifiers.CITY_MODIFIERS.HOLY_CITY)
        places_logic.save_place(self.p2)

        self.p1.persons[0].type = PERSON_TYPE.BLACKSMITH
        persons_logic.save_person(self.p1.persons[0])
Beispiel #8
0
    def test_initialize_bots__second_create(self):
        account_1 = self.accounts_factory.create_account()
        account_2 = self.accounts_factory.create_account(is_bot=True)

        storage = LogicStorage()
        storage.load_account_data(account_1)
        storage.load_account_data(account_2)

        hero_1 = storage.accounts_to_heroes[account_1.id]
        hero_2 = storage.accounts_to_heroes[account_2.id]

        hero_1._model.level = 50
        self.assertEqual(hero_2.level, 1)

        self.pvp_create_battle(account_1, account_2,
                               BATTLE_1X1_STATE.PROCESSING)
        self.pvp_create_battle(account_2, account_1,
                               BATTLE_1X1_STATE.PROCESSING)

        meta_action = meta_actions.ArenaPvP1x1.create(storage, hero_1, hero_2)
        meta_action.process_battle_ending()

        meta_actions.ArenaPvP1x1.create(storage, hero_1, hero_2)

        self.assertEqual(hero_2.level, 50)
        self.assertTrue(len(hero_2.abilities.all) > 1)
        self.assertEqual(hero_2.health, hero_2.max_health)
Beispiel #9
0
    def test_process_bot__flame_ability_not_used(self):
        account_1 = self.accounts_factory.create_account(is_bot=True)
        account_2 = self.accounts_factory.create_account()

        storage = LogicStorage()
        storage.load_account_data(account_1)
        storage.load_account_data(account_2)

        hero_1 = storage.accounts_to_heroes[account_1.id]
        hero_2 = storage.accounts_to_heroes[account_2.id]

        self.meta_action_battle.bot_pvp_properties = {
            'priorities': {
                Flame.TYPE: 1
            },
            'ability_chance': 1
        }

        self.assertEqual(hero_2.pvp.energy_speed, 1)

        with mock.patch('the_tale.game.pvp.abilities.Flame.use') as use:
            for i in xrange(100):
                self.meta_action_battle.process_bot(hero_1, hero_2)

        self.assertEqual(use.call_count, 0)
Beispiel #10
0
    def setUp(self):
        super(UsePvPAbilityTests, self).setUp()

        self.p1, self.p2, self.p3 = create_test_map()

        result, account_1_id, bundle_id = register_user(
            'test_user', '*****@*****.**', '111111')
        result, account_2_id, bundle_id = register_user(
            'test_user_2', '*****@*****.**', '111111')

        self.account_1 = AccountPrototype.get_by_id(account_1_id)
        self.account_2 = AccountPrototype.get_by_id(account_2_id)

        self.storage = LogicStorage()
        self.storage.load_account_data(self.account_1)
        self.storage.load_account_data(self.account_2)

        self.hero_1 = self.storage.accounts_to_heroes[self.account_1.id]
        self.hero_2 = self.storage.accounts_to_heroes[self.account_2.id]

        self.battle = Battle1x1Prototype.create(self.account_1)
        self.battle.set_enemy(self.account_2)
        self.battle.save()

        self.ability = random.choice(ABILITIES.values())

        self.task = UsePvPAbilityTask(battle_id=self.battle.id,
                                      account_id=self.account_1.id,
                                      ability_id=self.ability.TYPE)
Beispiel #11
0
    def setUp(self):
        super(CompanionTests, self).setUp()

        create_test_map()

        self.account = self.accounts_factory.create_account()

        self.storage = LogicStorage()
        self.storage.load_account_data(self.account)
        self.hero = self.storage.accounts_to_heroes[self.account.id]

        self.companion_record = logic.create_companion_record(
            utg_name=names.generator().get_test_name(),
            description='description',
            type=game_relations.BEING_TYPE.random(),
            max_health=10,
            dedication=relations.DEDICATION.random(),
            archetype=game_relations.ARCHETYPE.random(),
            mode=relations.MODE.random(),
            abilities=abilities_container.Container(),
            communication_verbal=game_relations.COMMUNICATION_VERBAL.random(),
            communication_gestures=game_relations.COMMUNICATION_GESTURES.
            random(),
            communication_telepathic=game_relations.COMMUNICATION_TELEPATHIC.
            random(),
            intellect_level=game_relations.INTELLECT_LEVEL.random(),
            state=relations.STATE.ENABLED)
        self.hero.set_companion(logic.create_companion(self.companion_record))
        self.companion = self.hero.companion
Beispiel #12
0
    def setUp(self):
        super(QuestInfoTests, self).setUp()

        self.place_1, self.place_2, self.place_3 = create_test_map()

        result, account_id, bundle_id = register_user('test_user')

        self.storage = LogicStorage()
        self.storage.load_account_data(AccountPrototype.get_by_id(account_id))
        self.hero = self.storage.accounts_to_heroes[account_id]

        self.action_idl = self.hero.actions.current_action
        self.action_idl.state = self.action_idl.STATE.QUEST

        self.quest = self.create_quest()

        self.start = self.quest.knowledge_base.filter(facts.Start).next()

        with mock.patch('the_tale.game.quests.writers.get_writer',
                        lambda **kwargs: FakeWriter(fake_uid='q', **kwargs)):
            self.quest_info = QuestInfo.construct(
                type=self.start.type,
                uid=self.start.uid,
                knowledge_base=self.quest.knowledge_base,
                hero=self.hero)
Beispiel #13
0
    def setUp(self):
        super(InPlaceActionCompanionDrinkArtifactTests, self).setUp()
        self.place_1, self.place_2, self.place_3 = create_test_map()

        self.account = self.accounts_factory.create_account()

        self.storage = LogicStorage()
        self.storage.load_account_data(self.account)
        self.hero = self.storage.accounts_to_heroes[self.account.id]

        self.action_idl = self.hero.actions.current_action

        self.companion_record = companions_logic.create_random_companion_record(
            'thief', state=companions_relations.STATE.ENABLED)
        self.hero.set_companion(
            companions_logic.create_companion(self.companion_record))

        self.hero._model.money = f.expected_gold_in_day(self.hero.level)

        self.hero.position.set_place(self.place_1)
        self.hero.position.visit_current_place()
        self.hero.position.set_place(self.place_2)

        self.artifact = artifacts_storage.generate_artifact_from_list(
            artifacts_storage.loot, 1, rarity=RARITY.NORMAL)
        self.hero.put_loot(self.artifact)

        self.assertEqual(self.hero.bag.occupation, 1)
Beispiel #14
0
    def setUp(self):
        super(QuestsTestBase, self).setUp()
        self.p1, self.p2, self.p3 = create_test_map()

        # add more persons, to lower conflicts
        places_logic.add_person_to_place(self.p1)
        places_logic.add_person_to_place(self.p1)
        places_logic.add_person_to_place(self.p2)
        places_logic.add_person_to_place(self.p2)
        places_logic.add_person_to_place(self.p3)
        places_logic.add_person_to_place(self.p3)

        account = self.accounts_factory.create_account(is_fast=True)

        self.storage = LogicStorage()
        self.storage.load_account_data(account)
        self.hero = self.storage.accounts_to_heroes[account.id]
        self.action_idl = self.hero.actions.current_action

        self.hero.money += 1
        self.hero.preferences.set_mob(mobs_storage.all()[0])
        self.hero.preferences.set_place(self.p1)
        self.hero.preferences.set_friend(self.p1.persons[0])
        self.hero.preferences.set_enemy(self.p2.persons[0])
        self.hero.preferences.set_equipment_slot(EQUIPMENT_SLOT.PLATE)
        self.hero.position.set_place(self.p3)
        heroes_logic.save_hero(self.hero)

        self.p2.set_modifier(places_modifiers.CITY_MODIFIERS.HOLY_CITY)
        places_logic.save_place(self.p2)

        self.p1.persons[0].type = PERSON_TYPE.BLACKSMITH
        persons_logic.save_person(self.p1.persons[0])
    def setUp(self):
        super(HabilitiesCompanionsTest, self).setUp()
        create_test_map()

        self.account = self.accounts_factory.create_account()
        self.storage = LogicStorage()
        self.storage.load_account_data(self.account)
        self.hero = self.storage.accounts_to_heroes[self.account.id]
Beispiel #16
0
    def setUp(self):
        super(ShopAccessoriesTest, self).setUp()
        self.place_1, self.place_2, self.place_3 = create_test_map()

        account = self.accounts_factory.create_account(is_fast=True)

        self.storage = LogicStorage()
        self.storage.load_account_data(account)
        self.hero = self.storage.accounts_to_heroes[account.id]
    def setUp(self):
        super(InvokeHeroMethodTaskTest, self).setUp()
        create_test_map()

        self.account = self.accounts_factory.create_account()
        self.storage = LogicStorage()
        self.storage.load_account_data(self.account)

        self.hero = self.storage.accounts_to_heroes[self.account.id]
Beispiel #18
0
    def setUp(self):
        super(ShopAccessoriesTest, self).setUp()
        self.place_1, self.place_2, self.place_3 = create_test_map()

        result, account_id, bundle_id = register_user('test_user')

        self.storage = LogicStorage()
        self.storage.load_account_data(AccountPrototype.get_by_id(account_id))
        self.hero = self.storage.accounts_to_heroes[account_id]
Beispiel #19
0
    def setUp(self):
        super(TestsBase, self).setUp()
        create_test_map()

        result, account_id, bundle_id = register_user('test_user')

        self.storage = LogicStorage()
        self.storage.load_account_data(AccountPrototype.get_by_id(account_id))
        self.hero = self.storage.accounts_to_heroes[account_id]
Beispiel #20
0
    def setUp(self):
        super(BaseHabitTest, self).setUp()

        create_test_map()

        account = self.accounts_factory.create_account(is_fast=True)

        self.storage = LogicStorage()
        self.storage.load_account_data(account)
        self.hero = self.storage.accounts_to_heroes[account.id]
    def setUp(self):
        super(CombineCardsTaskTest, self).setUp()
        place_1, place_2, place_3 = create_test_map()

        result, account_id, bundle_id = register_user('test_user', '*****@*****.**', '111111')
        self.account = AccountPrototype.get_by_id(account_id)
        self.storage = LogicStorage()
        self.storage.load_account_data(self.account)

        self.hero = self.storage.accounts_to_heroes[account_id]
    def test_merge_bundles(self):

        storage = LogicStorage()

        storage.bundles_to_accounts[555] = set([1, 2])
        storage.bundles_to_accounts[666] = set([3])

        storage.merge_bundles([555, 666], 777)

        self.assertEqual(storage.bundles_to_accounts, {777: set([1, 2, 3])})
Beispiel #23
0
    def setUp(self):
        super(AddBonusEnergyTestMixin, self).setUp()
        create_test_map()

        self.account_1 = self.accounts_factory.create_account()

        self.storage = LogicStorage()
        self.storage.load_account_data(self.account_1)

        self.hero = self.storage.accounts_to_heroes[self.account_1.id]
Beispiel #24
0
    def setUp(self):
        super(CommonTests, self).setUp()

        create_test_map()

        self.account = self.accounts_factory.create_account()

        self.storage = LogicStorage()
        self.storage.load_account_data(self.account)
        self.hero = self.storage.accounts_to_heroes[self.account.id]
Beispiel #25
0
    def setUp(self):
        super(ChooseAbilityTaskTest, self).setUp()

        create_test_map()

        account = self.accounts_factory.create_account()

        self.storage = LogicStorage()
        self.storage.load_account_data(account)
        self.hero = self.storage.accounts_to_heroes[account.id]
    def setUp(self):
        super(ChooseAbilityTaskTest, self).setUp()
        create_test_map()
        result, account_id, bundle_id = register_user('test_user',
                                                      '*****@*****.**',
                                                      '111111')

        self.storage = LogicStorage()
        self.storage.load_account_data(AccountPrototype.get_by_id(account_id))
        self.hero = self.storage.accounts_to_heroes[account_id]
    def setUp(self):
        super(HeroLogicAccessorsTestBase, self).setUp()

        self.place_1, self.place_2, self.place_3 = create_test_map()

        account = self.accounts_factory.create_account()

        self.storage = LogicStorage()
        self.storage.load_account_data(account)
        self.hero = self.storage.accounts_to_heroes[account.id]
Beispiel #28
0
    def setUp(self):
        super(SharpAllArtifactsTests, self).setUp()

        create_test_map()

        self.account_1 = self.accounts_factory.create_account()

        self.storage = LogicStorage()
        self.storage.load_account_data(self.account_1)

        self.hero = self.storage.accounts_to_heroes[self.account_1.id]
Beispiel #29
0
    def setUp(self):
        super(DropItemAbilityTest, self).setUp()

        create_test_map()

        self.account = self.accounts_factory.create_account()
        self.storage = LogicStorage()
        self.storage.load_account_data(self.account)
        self.hero = self.storage.accounts_to_heroes[self.account.id]

        self.ability = self.PROCESSOR()
Beispiel #30
0
    def setUp(self):
        super(HelpPlaceMixin, self).setUp()

        self.place_1, self.place_2, self.place_3 = create_test_map()

        self.account_1 = self.accounts_factory.create_account()

        self.storage = LogicStorage()
        self.storage.load_account_data(self.account_1)

        self.hero = self.storage.accounts_to_heroes[self.account_1.id]