def setUp(self):
super(PrototypeTests, self).setUp()
current_time = TimePrototype.get_current_time()
current_time.increment_turn()
self.persons_changed_at_turn = TimePrototype.get_current_turn_number()
self.p1, self.p2, self.p3 = create_test_map()
self.person = create_person(self.p1, PERSON_STATE.IN_GAME)
result, account_id, bundle_id = register_user('test_user1',
'*****@*****.**',
'111111')
self.hero_1 = HeroPrototype.get_by_account_id(account_id)
result, account_id, bundle_id = register_user('test_user2',
'*****@*****.**',
'111111')
self.hero_2 = HeroPrototype.get_by_account_id(account_id)
result, account_id, bundle_id = register_user('test_user3',
'*****@*****.**',
'111111')
self.hero_3 = HeroPrototype.get_by_account_id(account_id)
current_time = TimePrototype.get_current_time()
current_time.increment_turn()
def test_push_power(self):
self.place.push_power(0, 10)
self.assertEqual(self.place.power, 10)
TimePrototype.get_current_time().increment_turn()
self.place.push_power(1, 1)
self.assertEqual(self.place.power,
1 + 10*float(places_settings.POWER_HISTORY_LENGTH-1)/places_settings.POWER_HISTORY_LENGTH)
TimePrototype(places_settings.POWER_HISTORY_LENGTH-1).save()
self.place.push_power(places_settings.POWER_HISTORY_LENGTH-1, 100)
self.assertEqual(self.place.power,
100 + 10*1.0/places_settings.POWER_HISTORY_LENGTH + 2.0/places_settings.POWER_HISTORY_LENGTH)
TimePrototype(places_settings.POWER_HISTORY_LENGTH).save()
self.place.push_power(places_settings.POWER_HISTORY_LENGTH, 1000)
self.assertEqual(self.place.power,
1000 + 100*float(places_settings.POWER_HISTORY_LENGTH-1)/places_settings.POWER_HISTORY_LENGTH + 1.0/places_settings.POWER_HISTORY_LENGTH)
TimePrototype(places_settings.POWER_HISTORY_LENGTH+1).save()
self.place.push_power(places_settings.POWER_HISTORY_LENGTH+1, 10000)
self.assertEqual(self.place.power,
10000 +
1000*float(places_settings.POWER_HISTORY_LENGTH-1)/places_settings.POWER_HISTORY_LENGTH +
100*float(places_settings.POWER_HISTORY_LENGTH-2)/places_settings.POWER_HISTORY_LENGTH)
TimePrototype(places_settings.POWER_HISTORY_LENGTH+2).save()
self.place.push_power(places_settings.POWER_HISTORY_LENGTH+2, 100000)
self.assertEqual(round(self.place.power, 5),
round(100000 +
10000*float(places_settings.POWER_HISTORY_LENGTH-1)/places_settings.POWER_HISTORY_LENGTH +
1000*float(places_settings.POWER_HISTORY_LENGTH-2)/places_settings.POWER_HISTORY_LENGTH +
100*float(places_settings.POWER_HISTORY_LENGTH-3)/places_settings.POWER_HISTORY_LENGTH, 5) )
def setUp(self):
super(TestPrototypeEnd, self).setUp()
bill_data = PlaceRenaming(place_id=self.place1.id, name_forms=names.generator.get_test_name('new_name_1'))
self.bill = BillPrototype.create(self.account1, 'bill-1-caption', 'bill-1-rationale', bill_data, chronicle_on_accepted='chronicle-on-accepted')
self.bill.state = relations.BILL_STATE.ACCEPTED
TimePrototype.get_current_time().increment_turn()
def setUp(self):
super(TestPrototypeEnd, self).setUp()
bill_data = PlaceRenaming(place_id=self.place1.id, name_forms=names.generator().get_test_name('new_name_1'))
self.bill = BillPrototype.create(self.account1, 'bill-1-caption', 'bill-1-rationale', bill_data, chronicle_on_accepted='chronicle-on-accepted')
self.bill.state = relations.BILL_STATE.ACCEPTED
TimePrototype.get_current_time().increment_turn()
def test_increment_turn(self):
time = TimePrototype.get_current_time()
self.assertEqual(time.turn_number, 0)
time.increment_turn()
self.assertEqual(time.turn_number, 1)
time.save()
time = TimePrototype.get_current_time()
self.assertEqual(time.turn_number, 1)
def test_increment_turn(self):
time = TimePrototype.get_current_time()
self.assertEqual(time.turn_number, 0)
time.increment_turn()
self.assertEqual(time.turn_number, 1)
time.save()
time = TimePrototype.get_current_time()
self.assertEqual(time.turn_number, 1)
def test_creation(self):
Setting.objects.all().delete()
settings.refresh()
settings_number = Setting.objects.all().count()
time = TimePrototype.get_current_time()
self.assertEqual(time.turn_number, 0)
self.assertEqual(Setting.objects.all().count(), settings_number + 1)
time = TimePrototype.get_current_time()
self.assertEqual(time.turn_number, 0)
self.assertEqual(Setting.objects.all().count(), settings_number + 1)
def test_creation(self):
Setting.objects.all().delete()
settings.refresh()
settings_number = Setting.objects.all().count()
time = TimePrototype.get_current_time()
self.assertEqual(time.turn_number, 0)
self.assertEqual(Setting.objects.all().count(), settings_number+1)
time = TimePrototype.get_current_time()
self.assertEqual(time.turn_number, 0)
self.assertEqual(Setting.objects.all().count(), settings_number+1)
def test_move_out_game(self):
self.assertEqual(self.person.place.persons_changed_at_turn, self.persons_changed_at_turn)
TimePrototype.get_current_time().increment_turn()
current_time = datetime.datetime.now()
self.assertTrue(self.person.out_game_at < current_time)
self.assertEqual(self.person.state, PERSON_STATE.IN_GAME)
self.person.move_out_game()
self.assertTrue(self.person.out_game_at > current_time)
self.assertEqual(self.person.state, PERSON_STATE.OUT_GAME)
self.assertEqual(self.person.place.persons_changed_at_turn, TimePrototype.get_current_turn_number())
def test_move_out_game(self):
self.assertEqual(self.person.place.persons_changed_at_turn,
self.persons_changed_at_turn)
TimePrototype.get_current_time().increment_turn()
current_time = datetime.datetime.now()
self.assertTrue(self.person.out_game_at < current_time)
self.assertEqual(self.person.state, PERSON_STATE.IN_GAME)
self.person.move_out_game()
self.assertTrue(self.person.out_game_at > current_time)
self.assertEqual(self.person.state, PERSON_STATE.OUT_GAME)
self.assertEqual(self.person.place.persons_changed_at_turn,
TimePrototype.get_current_turn_number())
def test_user_form__move_delay(self):
data = {'caption': 'caption-caption',
'rationale': 'rationale',
'chronicle_on_accepted': 'chronicle-on-accepted',
'person': self.person_2.id,
'new_place': self.place3.id}
form = self.bill.data.get_user_form_update(post=data, owner_id=self.account.id)
self.assertFalse(form.is_valid())
TimePrototype.get_current_time().increment_turn()
form = self.bill.data.get_user_form_update(post=data, owner_id=self.account.id)
self.assertTrue(form.is_valid())
def test_no_stop_when_quest_required_replane(self):
self.action_idl.percents = 0.0
self.assertFalse(self.action_trade.replane_required)
artifact = artifacts_storage.generate_artifact_from_list(artifacts_storage.artifacts, self.hero.level, rarity=RARITY.NORMAL)
self.hero.bag.put_artifact(artifact)
artifact = artifacts_storage.generate_artifact_from_list(artifacts_storage.artifacts, self.hero.level, rarity=RARITY.NORMAL)
self.hero.bag.put_artifact(artifact)
self.action_trade.percents_barier = 2
self.assertEqual(self.hero.bag.occupation, 2)
current_time = TimePrototype.get_current_time()
self.storage.process_turn()
self.assertEqual(self.hero.bag.occupation, 1)
self.assertEqual(len(self.hero.actions.actions_list), 2)
self.assertEqual(self.hero.actions.current_action, self.action_trade)
self.action_trade.replane_required = True
current_time.increment_turn()
self.storage.process_turn(continue_steps_if_needed=False)
self.assertEqual(self.hero.bag.occupation, 0)
self.assertEqual(len(self.hero.actions.actions_list), 1)
self.assertEqual(self.action_trade.state, self.action_trade.STATE.PROCESSED)
self.assertEqual(self.hero.actions.current_action, self.action_idl)
def test_sequence_move(self):
current_time = TimePrototype.get_current_time()
while self.hero.actions.current_action != self.action_idl:
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertEqual(self.hero.position.road.point_1_id, self.p2.id)
self.assertEqual(self.hero.position.road.point_2_id, self.p3.id)
real_percents = None
prototypes.ActionMoveToPrototype.create(hero=self.hero, destination=self.p1, break_at=0.9)
while self.hero.actions.current_action != self.action_idl:
real_percents = self.hero.actions.current_action.percents
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertEqual(round(real_percents, 1), 0.9)
self.assertEqual(self.hero.position.road.point_1_id, self.p1.id)
self.assertEqual(self.hero.position.road.point_2_id, self.p2.id)
prototypes.ActionMoveToPrototype.create(hero=self.hero, destination=self.p2)
while self.hero.position.place is None or self.hero.position.place.id != self.p2.id:
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertEqual(self.hero.actions.current_action.TYPE, prototypes.ActionInPlacePrototype.TYPE)
self.storage._test_save()
def form_game_info(account=None, is_own=False, client_turns=None):
from the_tale.accounts.prototypes import AccountPrototype
from the_tale.game.prototypes import GameState
from the_tale.game.pvp.prototypes import Battle1x1Prototype
game_time = TimePrototype.get_current_time()
data = {'mode': 'pve',
'turn': game_time.ui_info(),
'game_state': GameState.state().value,
'map_version': map_info_storage.version,
'account': None,
'enemy': None }
if account:
battle = Battle1x1Prototype.get_by_account_id(account.id)
data['account'] = _form_game_account_info(game_time,
account,
in_pvp_queue=False if battle is None else battle.state.is_WAITING,
is_own=is_own,
client_turns=client_turns)
if battle and battle.state.is_PROCESSING:
data['mode'] = 'pvp'
data['enemy'] = _form_game_account_info(game_time,
AccountPrototype.get_by_id(battle.enemy_id),
in_pvp_queue=False,
is_own=False,
client_turns=client_turns)
return data
def _end_battle(self, hero_1_health, hero_2_health):
self.hero_1.health = hero_1_health
self.hero_2.health = hero_2_health
current_time = TimePrototype.get_current_time()
self.meta_action_battle.process()
current_time.increment_turn()
self.meta_action_battle.process()
def test_sync_persons_add_new_person__force_when_zero_persons(self):
TimePrototype.get_current_time().increment_turn()
self.assertEqual(self.place.persons_changed_at_turn, 0)
self.assertFalse(self.place.can_add_person)
old_persons = self.place.persons
for person in self.place.persons:
person.move_out_game()
self.place.sync_persons(force_add=False)
self.assertEqual(self.place.persons_changed_at_turn, TimePrototype.get_current_turn_number())
self.assertEqual(len(self.place.persons), 1)
self.assertFalse(self.place.persons[0] in old_persons)
def quest_test_method(self):
# defends from first quest rule
self.hero.statistics.change_quests_done(1)
heroes_logic.save_hero(self.hero)
current_time = TimePrototype.get_current_time()
test_upgrade_equipment = random.randint(
0, 1) # test child quest or upgrade equipment for SearchSmith
while self.hero.actions.current_action.TYPE != ActionQuestPrototype.TYPE or not self.hero.quests.has_quests:
if quest == SearchSmith and test_upgrade_equipment:
self.hero.money = QuestPrototype.upgrade_equipment_cost(
self.hero) * 2
self.hero.next_spending = ITEMS_OF_EXPENDITURE.INSTANT_HEAL
self.storage.process_turn()
current_time.increment_turn()
# test if quest is serializable
s11n.to_json(self.hero.quests.current_quest.serialize())
self.complete_quest()
self.assertEqual(self.hero.actions.current_action.TYPE,
ActionIdlenessPrototype.TYPE)
if quest == SearchSmith and test_upgrade_equipment:
self.assertTrue(
self.hero.statistics.money_spend_for_artifacts > 0
or self.hero.statistics.money_spend_for_sharpening > 0)
def test_processed(self):
current_time = TimePrototype.get_current_time()
self.assertEqual(self.hero.journal.messages_number(), 2)
with self.check_calls_count("the_tale.game.heroes.logic.push_message_to_diary", 0):
self.storage.process_turn()
current_time.increment_turn()
self.assertEqual(self.hero.journal.messages_number(), 3)
self.storage.process_turn()
current_time.increment_turn()
self.assertEqual(self.hero.journal.messages_number(), 4)
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertEqual(self.hero.journal.messages_number(), 5)
self.assertTrue(self.hero.actions.current_action.TYPE.is_IDLENESS)
self.storage._test_save()
def test_sell_and_continue(self):
old_money = self.hero.money
artifact = artifacts_storage.generate_artifact_from_list(artifacts_storage.artifacts, self.hero.level, rarity=RARITY.NORMAL)
self.hero.bag.put_artifact(artifact)
artifact = artifacts_storage.generate_artifact_from_list(artifacts_storage.artifacts, self.hero.level, rarity=RARITY.NORMAL)
self.hero.bag.put_artifact(artifact)
self.assertEqual(self.hero.bag.occupation, 2)
self.action_trade.percents_barier = 2
current_time = TimePrototype.get_current_time()
self.storage.process_turn()
self.assertEqual(len(self.hero.actions.actions_list), 2)
self.assertEqual(self.hero.actions.current_action, self.action_trade)
self.assertEqual(self.hero.bag.occupation, 1)
self.assertTrue(self.hero.money > old_money)
old_money = self.hero.money
current_time.increment_turn()
self.storage.process_turn(continue_steps_if_needed=False)
self.assertEqual(len(self.hero.actions.actions_list), 1)
self.assertEqual(self.hero.actions.current_action, self.action_idl)
self.assertEqual(self.hero.bag.occupation, 0)
self.assertTrue(self.hero.money > old_money)
self.storage._test_save()
def form_game_info(account=None, is_own=False, client_turns=None):
from the_tale.accounts.prototypes import AccountPrototype
from the_tale.game.prototypes import GameState
from the_tale.game.pvp.prototypes import Battle1x1Prototype
game_time = TimePrototype.get_current_time()
data = {'mode': 'pve',
'turn': game_time.ui_info(),
'game_state': GameState.state().value,
'map_version': map_info_storage.version,
'account': None,
'enemy': None }
if account:
battle = Battle1x1Prototype.get_by_account_id(account.id)
data['account'] = _form_game_account_info(game_time,
account,
in_pvp_queue=False if battle is None else battle.state.is_WAITING,
is_own=is_own,
client_turns=client_turns)
if battle and battle.state.is_PROCESSING:
data['mode'] = 'pvp'
data['enemy'] = _form_game_account_info(game_time,
AccountPrototype.get_by_id(battle.enemy_id),
in_pvp_queue=False,
is_own=False,
client_turns=client_turns)
return data
def test_process_next_turn(self):
time = TimePrototype.get_current_time()
time.increment_turn()
time.save()
self.assertEqual(time.turn_number, 1)
for i in xrange(c.MAP_SYNC_TIME - 1):
self.worker.process_next_turn(time.turn_number)
self.assertFalse(hasattr(self.worker, "_data_synced"))
if time.turn_number < bills_settings.BILLS_PROCESS_INTERVAL / c.TURN_DELTA:
self.assertFalse(hasattr(self.worker, "_bills_applied"))
else:
self.assertEqual(
self.worker._bills_applied,
time.turn_number / (bills_settings.BILLS_PROCESS_INTERVAL / c.TURN_DELTA),
)
time.increment_turn()
time.save()
self.worker.process_next_turn(time.turn_number)
self.assertTrue(self.worker._data_synced)
def test_stop_when_quest_required_replane(self):
self.action_idl.percents = 0.0
self.assertFalse(self.action_trade.replane_required)
artifact = artifacts_storage.generate_artifact_from_list(artifacts_storage.artifacts, self.hero.level, rarity=RARITY.NORMAL)
self.hero.bag.put_artifact(artifact)
artifact = artifacts_storage.generate_artifact_from_list(artifacts_storage.artifacts, self.hero.level, rarity=RARITY.NORMAL)
self.hero.bag.put_artifact(artifact)
self.action_trade.percents_barier = 2
self.assertEqual(self.hero.bag.occupation, 2)
current_time = TimePrototype.get_current_time()
self.storage.process_turn()
self.assertEqual(self.hero.bag.occupation, 1)
self.assertEqual(len(self.hero.actions.actions_list), 2)
self.assertEqual(self.hero.actions.current_action, self.action_trade)
self.action_trade.replane_required = True
current_time.increment_turn()
self.storage.process_turn(continue_steps_if_needed=False)
self.assertEqual(self.hero.bag.occupation, 1)
self.assertEqual(len(self.hero.actions.actions_list), 1)
self.assertEqual(self.action_trade.state, self.action_trade.STATE.PROCESSED)
self.assertEqual(self.hero.actions.current_action, self.action_idl)
def test_sell_and_continue(self):
old_money = self.hero.money
artifact = artifacts_storage.generate_artifact_from_list(artifacts_storage.artifacts, self.hero.level, rarity=RARITY.NORMAL)
self.hero.bag.put_artifact(artifact)
artifact = artifacts_storage.generate_artifact_from_list(artifacts_storage.artifacts, self.hero.level, rarity=RARITY.NORMAL)
self.hero.bag.put_artifact(artifact)
self.assertEqual(self.hero.bag.occupation, 2)
self.action_trade.percents_barier = 2
current_time = TimePrototype.get_current_time()
self.storage.process_turn()
self.assertEqual(len(self.hero.actions.actions_list), 2)
self.assertEqual(self.hero.actions.current_action, self.action_trade)
self.assertEqual(self.hero.bag.occupation, 1)
self.assertTrue(self.hero.money > old_money)
old_money = self.hero.money
current_time.increment_turn()
self.storage.process_turn(continue_steps_if_needed=False)
self.assertEqual(len(self.hero.actions.actions_list), 1)
self.assertEqual(self.hero.actions.current_action, self.action_idl)
self.assertEqual(self.hero.bag.occupation, 0)
self.assertTrue(self.hero.money > old_money)
self.storage._test_save()
def test_not_enough_voices_percents(self):
current_time = TimePrototype.get_current_time()
current_time.increment_turn()
current_time.increment_turn()
VotePrototype.create(self.account2, self.bill,
relations.VOTE_TYPE.AGAINST)
VotePrototype.create(self.account3, self.bill,
relations.VOTE_TYPE.REFRAINED)
self.assertEqual(Post.objects.all().count(), 1)
with mock.patch(
'the_tale.accounts.workers.accounts_manager.Worker.cmd_run_account_method'
) as cmd_run_account_method:
self.assertFalse(self.bill.apply())
self.assertEqual(cmd_run_account_method.call_count, 0)
self.assertTrue(self.bill.state.is_REJECTED)
self.assertEqual(Post.objects.all().count(), 2)
bill = BillPrototype.get_by_id(self.bill.id)
self.assertTrue(bill.state.is_REJECTED)
places_storage.sync(force=True)
self.place1.sync_parameters()
self.assertEqual(self.place1.stability, 1.0)
self.assertEqual(bill.applyed_at_turn, current_time.turn_number)
self.check_place(self.place1.id, self.place1.name,
self.place1.utg_name.forms)
def test_lighting(self):
current_time = TimePrototype.get_current_time()
action_battle = actions_prototypes.ActionBattlePvE1x1Prototype.create(
hero=self.hero, mob=mobs_storage.create_mob_for_hero(self.hero))
current_time.increment_turn()
self.storage.process_turn()
old_mob_health = action_battle.mob.health
old_percents = action_battle.percents
self.assertTrue(HELP_CHOICES.LIGHTING in action_battle.help_choices)
with mock.patch(
'the_tale.game.actions.prototypes.ActionBase.get_help_choice',
lambda x: HELP_CHOICES.LIGHTING):
with self.check_delta(lambda: self.hero.statistics.help_count, 1):
self.assertEqual(self.ability.use(**self.use_attributes),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
self.assertTrue(old_mob_health > action_battle.mob.health)
self.assertEqual(self.hero.actions.current_action.percents,
action_battle.percents)
self.assertTrue(old_percents < action_battle.percents)
def _end_battle(self, hero_1_health, hero_2_health):
self.hero_1.health = hero_1_health
self.hero_2.health = hero_2_health
current_time = TimePrototype.get_current_time()
self.meta_action_battle.process()
current_time.increment_turn()
self.meta_action_battle.process()
def test_sequence_move(self):
current_time = TimePrototype.get_current_time()
while self.hero.actions.current_action != self.action_idl:
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertEqual(self.hero.position.road.point_1_id, self.p2.id)
self.assertEqual(self.hero.position.road.point_2_id, self.p3.id)
real_percents = None
prototypes.ActionMoveToPrototype.create(hero=self.hero,
destination=self.p1,
break_at=0.9)
while self.hero.actions.current_action != self.action_idl:
real_percents = self.hero.actions.current_action.percents
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertEqual(round(real_percents, 1), 0.9)
self.assertEqual(self.hero.position.road.point_1_id, self.p1.id)
self.assertEqual(self.hero.position.road.point_2_id, self.p2.id)
prototypes.ActionMoveToPrototype.create(hero=self.hero,
destination=self.p2)
while self.hero.position.place is None or self.hero.position.place.id != self.p2.id:
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertEqual(self.hero.actions.current_action.TYPE,
prototypes.ActionInPlacePrototype.TYPE)
self.storage._test_save()
def get_power_points():
month = TimePrototype.get_current_time().game_time.month_record
points = []
points = [
_default_temperature_points(delta={
MONTHS.COLD: -0.1,
MONTHS.HOT: 0.1
}.get(month, 0)),
_default_wetness_points(delta={
MONTHS.DRY: -0.1,
MONTHS.CRUDE: 0.1
}.get(month, 0)),
_default_vegetation_points(),
_default_soil_points()
]
for place in places_storage.all():
points.extend(get_place_power_points(place))
for race in RACE.records:
points.extend(get_place_race_power_points(place, race))
for building in buildings_storage.all():
points.extend(get_building_power_points(building))
return points
def test_not_enough_voices_percents(self):
current_time = TimePrototype.get_current_time()
current_time.increment_turn()
current_time.increment_turn()
VotePrototype.create(self.account2, self.bill, relations.VOTE_TYPE.AGAINST)
VotePrototype.create(self.account3, self.bill, relations.VOTE_TYPE.REFRAINED)
self.assertEqual(Post.objects.all().count(), 1)
with self.check_not_changed(lambda: self.place1.attrs.stability):
with mock.patch('the_tale.accounts.workers.accounts_manager.Worker.cmd_run_account_method') as cmd_run_account_method:
self.assertFalse(self.bill.apply())
self.assertEqual(cmd_run_account_method.call_count, 0)
self.assertTrue(self.bill.state.is_REJECTED)
self.assertEqual(Post.objects.all().count(), 2)
bill = BillPrototype.get_by_id(self.bill.id)
self.assertTrue(bill.state.is_REJECTED)
places_storage.places.sync(force=True)
self.place1.refresh_attributes()
self.assertEqual(bill.applyed_at_turn, current_time.turn_number)
self.check_place(self.place1.id, self.place1.name, self.place1.utg_name.forms)
def test_teleport(self):
move_place = self.p3
if move_place.id == self.hero.position.place.id:
move_place = self.p1
current_time = TimePrototype.get_current_time()
action_move = actions_prototypes.ActionMoveToPrototype.create(
hero=self.hero, destination=move_place)
current_time.increment_turn()
self.storage.process_turn()
old_road_percents = self.hero.position.percents
old_percents = action_move.percents
with mock.patch(
'the_tale.game.actions.prototypes.ActionBase.get_help_choice',
lambda x: HELP_CHOICES.TELEPORT):
with self.check_delta(lambda: self.hero.statistics.help_count, 1):
self.assertEqual(self.ability.use(**self.use_attributes),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
self.assertTrue(old_road_percents < self.hero.position.percents)
self.assertTrue(old_percents < action_move.percents)
self.assertEqual(self.hero.actions.current_action.percents,
action_move.percents)
def test_teleport__length_is_0(self):
current_time = TimePrototype.get_current_time()
self.storage.process_turn(continue_steps_if_needed=False)
self.action_move.length = 0
self.action_move.percents = 1
self.hero.position.percents = 1
with self.check_not_changed(lambda: self.action_move.percents):
self.action_move.teleport(1, create_inplace_action=True)
self.assertEqual(self.action_move.state,
self.action_move.STATE.PROCESSED)
self.assertTrue(self.action_move.updated)
current_time.increment_turn()
self.storage.process_turn(continue_steps_if_needed=False)
self.assertEqual(self.hero.position.place.id, self.p2.id)
self.storage._test_save()
def quest_test_method(self):
# defends from first quest rule
self.hero.statistics.change_quests_done(1)
self.hero.save()
current_time = TimePrototype.get_current_time()
test_upgrade_equipment = random.randint(0, 1) # test child quest or upgrade equipment for SearchSmith
while self.hero.actions.current_action.TYPE != ActionQuestPrototype.TYPE or not self.hero.quests.has_quests:
if quest == SearchSmith and test_upgrade_equipment:
self.hero._model.money = QuestPrototype.upgrade_equipment_cost(self.hero) * 2
self.hero._model.next_spending = ITEMS_OF_EXPENDITURE.INSTANT_HEAL
self.storage.process_turn()
current_time.increment_turn()
# test if quest is serializable
s11n.to_json(self.hero.quests.current_quest.serialize())
self.complete_quest()
self.assertEqual(self.hero.actions.current_action.TYPE, ActionIdlenessPrototype.TYPE)
if quest == SearchSmith and test_upgrade_equipment:
self.assertTrue(self.hero.statistics.money_spend_for_artifacts > 0 or
self.hero.statistics.money_spend_for_sharpening > 0)
def test_process_next_turn_with_skipped_hero(self):
current_time = TimePrototype.get_current_time()
current_time.increment_turn()
current_time.save()
self.worker.process_register_account(self.account.id)
self.worker.storage.skipped_heroes.add(self.hero.id)
with mock.patch(
'the_tale.game.actions.prototypes.ActionBase.process_turn'
) as action_process_turn:
with mock.patch(
'the_tale.game.workers.supervisor.Worker.cmd_account_release_required'
) as release_required_counter:
with mock.patch('the_tale.game.heroes.logic.save_hero'
) as save_counter:
with mock.patch(
'the_tale.game.conf.game_settings.SAVED_UNCACHED_HEROES_FRACTION',
0):
self.worker.process_next_turn(
TimePrototype.get_current_turn_number())
self.assertEqual(action_process_turn.call_count, 0)
self.assertEqual(save_counter.call_count, 1)
self.assertEqual(release_required_counter.call_count, 1)
def test_processed(self):
current_time = TimePrototype.get_current_time()
self.assertEqual(self.hero.journal.messages_number(), 2)
with self.check_calls_count(
'the_tale.game.heroes.logic.push_message_to_diary', 0):
self.storage.process_turn()
current_time.increment_turn()
self.assertEqual(self.hero.journal.messages_number(), 3)
self.storage.process_turn()
current_time.increment_turn()
self.assertEqual(self.hero.journal.messages_number(), 4)
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertEqual(self.hero.journal.messages_number(), 5)
self.assertTrue(self.hero.actions.current_action.TYPE.is_IDLENESS)
self.storage._test_save()
def test_move_change_place_coordinates_and_back(self):
current_time = TimePrototype.get_current_time()
while len(self.hero.actions.actions_list) != 1:
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertEqual(self.hero.actions.current_action.TYPE,
prototypes.ActionIdlenessPrototype.TYPE)
self.assertTrue(self.hero.position.is_walking
or self.hero.position.place) # can end in start place
prototypes.ActionMoveNearPlacePrototype.create(hero=self.hero,
place=self.p1,
back=True)
self.p1.x = self.p1.x + 1
self.p1.y = self.p1.y + 1
places_logic.save_place(self.p1)
while self.hero.position.place is None or self.hero.position.place.id != self.p1.id:
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertEqual(self.hero.actions.current_action.TYPE,
prototypes.ActionInPlacePrototype.TYPE)
self.assertTrue(not self.hero.position.is_walking)
self.storage._test_save()
def test_full_battle__with_companion(self):
battle_ability = random.choice([
ability for ability in effects.ABILITIES.records
if isinstance(ability.effect, effects.BaseBattleAbility)
])
companion_record = companions_storage.companions.enabled_companions(
).next()
companion_record.abilities = container.Container(
start=(battle_ability, ))
companion = companions_logic.create_companion(companion_record)
self.hero.set_companion(companion)
self.hero.reset_accessors_cache()
current_time = TimePrototype.get_current_time()
while len(self.hero.actions.actions_list) != 1:
self.storage.process_turn()
current_time.increment_turn()
self.assertTrue(self.action_idl.leader)
self.storage._test_save()
def test_push_power(self):
self.place.push_power(0, 10)
self.assertEqual(self.place.power, 10)
TimePrototype.get_current_time().increment_turn()
self.place.push_power(1, 1)
self.assertEqual(
self.place.power,
1 + 10 * float(places_settings.POWER_HISTORY_LENGTH - 1) /
places_settings.POWER_HISTORY_LENGTH)
TimePrototype(places_settings.POWER_HISTORY_LENGTH - 1).save()
self.place.push_power(places_settings.POWER_HISTORY_LENGTH - 1, 100)
self.assertEqual(
self.place.power,
100 + 10 * 1.0 / places_settings.POWER_HISTORY_LENGTH +
2.0 / places_settings.POWER_HISTORY_LENGTH)
TimePrototype(places_settings.POWER_HISTORY_LENGTH).save()
self.place.push_power(places_settings.POWER_HISTORY_LENGTH, 1000)
self.assertEqual(
self.place.power,
1000 + 100 * float(places_settings.POWER_HISTORY_LENGTH - 1) /
places_settings.POWER_HISTORY_LENGTH +
1.0 / places_settings.POWER_HISTORY_LENGTH)
TimePrototype(places_settings.POWER_HISTORY_LENGTH + 1).save()
self.place.push_power(places_settings.POWER_HISTORY_LENGTH + 1, 10000)
self.assertEqual(
self.place.power,
10000 + 1000 * float(places_settings.POWER_HISTORY_LENGTH - 1) /
places_settings.POWER_HISTORY_LENGTH +
100 * float(places_settings.POWER_HISTORY_LENGTH - 2) /
places_settings.POWER_HISTORY_LENGTH)
TimePrototype(places_settings.POWER_HISTORY_LENGTH + 2).save()
self.place.push_power(places_settings.POWER_HISTORY_LENGTH + 2, 100000)
self.assertEqual(
round(self.place.power, 5),
round(
100000 +
10000 * float(places_settings.POWER_HISTORY_LENGTH - 1) /
places_settings.POWER_HISTORY_LENGTH +
1000 * float(places_settings.POWER_HISTORY_LENGTH - 2) /
places_settings.POWER_HISTORY_LENGTH +
100 * float(places_settings.POWER_HISTORY_LENGTH - 3) /
places_settings.POWER_HISTORY_LENGTH, 5))
def complete_quest(self):
current_time = TimePrototype.get_current_time()
while not self.action_idl.leader:
self.storage.process_turn()
current_time.increment_turn()
self.hero.ui_info(actual_guaranteed=True) # test if ui info formed correctly
def complete_quest(self):
current_time = TimePrototype.get_current_time()
while not self.action_idl.leader:
self.storage.process_turn()
current_time.increment_turn()
self.hero.ui_info(actual_guaranteed=True) # test if ui info formed correctly
def test_sync_persons_add_new_person__force_when_zero_persons(self):
TimePrototype.get_current_time().increment_turn()
self.assertEqual(self.place.persons_changed_at_turn, 0)
self.assertFalse(self.place.can_add_person)
old_persons = self.place.persons
for person in self.place.persons:
person.move_out_game()
self.place.sync_persons(force_add=False)
self.assertEqual(self.place.persons_changed_at_turn,
TimePrototype.get_current_turn_number())
self.assertEqual(len(self.place.persons), 1)
self.assertFalse(self.place.persons[0] in old_persons)
def test_percents_consistency(self):
current_time = TimePrototype.get_current_time()
# just test that quest will be ended
while not self.action_idl.leader:
self.storage.process_turn()
current_time.increment_turn()
self.assertEqual(self.storage.tests_get_last_action().percents, self.hero.last_action_percents)
def test_companion_healing_by_hero__not_healed(self):
current_time = TimePrototype.get_current_time()
self.hero.companion.health = 1
with self.check_delta(lambda: self.hero.companion.health, c.COMPANIONS_HEALTH_PER_HEAL):
self.action_heal_companion.state = self.action_heal_companion.STATE.PROCESSED
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
def test_full(self):
current_time = TimePrototype.get_current_time()
while not self.action_idl.leader:
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.storage._test_save()
def update_map(index):
generator = WorldInfoPrototype.get_by_id(map_info_storage.item.world_id).generator
generator.clear_power_points()
generator.clear_biomes()
if generator.w != map_settings.WIDTH or generator.h != map_settings.HEIGHT:
dx, dy = generator.resize(map_settings.WIDTH, map_settings.HEIGHT)
places_storage.places.shift_all(dx, dy)
places_storage.buildings.shift_all(dx, dy)
for point in get_power_points():
generator.add_power_point(point)
for terrain in TERRAIN.records:
generator.add_biom(Biom(id_=terrain))
generator.do_step()
biomes_map = generator.get_biomes_map()
time = TimePrototype.get_current_time()
draw_info = get_draw_info(biomes_map)
terrain = []
for y in range(0, generator.h):
row = []
terrain.append(row)
for x in range(0, generator.w):
row.append(biomes_map[y][x].id)
map_info_storage.set_item(MapInfoPrototype.create(turn_number=time.turn_number,
width=generator.w,
height=generator.h,
terrain=terrain,
world=WorldInfoPrototype.create_from_generator(generator)))
MapInfoPrototype.remove_old_infos()
raw_draw_info = []
for row in draw_info:
raw_draw_info.append([])
for cell in row:
raw_draw_info[-1].append(cell.get_sprites())
data = {'width': generator.w,
'height': generator.h,
'map_version': map_info_storage.version,
'format_version': '0.1',
'draw_info': raw_draw_info,
'places': dict( (place.id, place.map_info() ) for place in places_storage.places.all() ),
# 'buildings': dict( (building.id, building.map_info() ) for building in buildings_storage.all() ),
'roads': dict( (road.id, road.map_info() ) for road in roads_storage.all()) }
models.MapRegion.objects.create(turn_number=time.turn_number, data=data)
def test_post_created_at_turn(self):
current_turn = TimePrototype.get_current_time()
current_turn.increment_turn()
current_turn.increment_turn()
ThreadPrototype.create(self.subcategory, 'thread-2-caption', self.account, 'thread-2-text')
self.assertEqual(PostPrototype._db_latest().created_at_turn, current_turn.turn_number)
def test_created_at_turn(self):
current_turn = TimePrototype.get_current_time()
current_turn.increment_turn()
current_turn.increment_turn()
post = PostPrototype.create(thread=self.thread, author=self.account, text='post-1-text')
self.assertEqual(post.created_at_turn, current_turn.turn_number)
def test_full(self):
current_time = TimePrototype.get_current_time()
while not self.action_idl.leader:
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.storage._test_save()
def test_approved(self):
current_time = TimePrototype.get_current_time()
current_time.increment_turn()
current_time.increment_turn()
current_time.increment_turn()
VotePrototype.create(self.account2, self.bill,
relations.VOTE_TYPE.AGAINST)
VotePrototype.create(self.account3, self.bill, relations.VOTE_TYPE.FOR)
VotePrototype.create(self.account4, self.bill,
relations.VOTE_TYPE.REFRAINED)
##################################
# set name forms
data = self.bill.user_form_initials
data.update(
linguistics_helpers.get_word_post_data(self.bill.data.name_forms,
prefix='name'))
data['approved'] = True
form = self.bill.data.get_moderator_form_update(data)
self.assertTrue(form.is_valid())
self.bill.update_by_moderator(form)
##################################
self.assertEqual(Post.objects.all().count(), 1)
with mock.patch(
'the_tale.accounts.workers.accounts_manager.Worker.cmd_run_account_method'
) as cmd_run_account_method:
self.assertTrue(self.bill.apply())
self.assertEqual(cmd_run_account_method.call_args_list, [
mock.call(account_id=self.bill.owner.id,
method_name=accounts_prototypes.AccountPrototype.
update_actual_bills.__name__,
data={})
])
self.assertTrue(self.bill.state.is_ACCEPTED)
self.assertEqual(Post.objects.all().count(), 2)
bill = BillPrototype.get_by_id(self.bill.id)
self.assertTrue(bill.state.is_ACCEPTED)
places_storage.places.sync(force=True)
self.place1.refresh_attributes()
self.assertTrue(self.place1.attrs.stability < 1.0)
self.assertEqual(bill.applyed_at_turn, current_time.turn_number)
self.check_place(self.place1.id, 'new_name_1-нс,ед,им',
self.bill.data.name_forms.forms)
def test_buy_meal__from_moveto(self):
prototypes.ActionMoveToPrototype.create(hero=self.hero, destination=self.place_3)
current_time = TimePrototype.get_current_time()
with contextlib.nested( self.check_decreased(lambda: self.hero.money),
self.check_increased(lambda: self.hero.statistics.money_spend_for_companions)):
while self.hero.actions.current_action.TYPE != prototypes.ActionInPlacePrototype.TYPE:
current_time.increment_turn()
self.storage.process_turn(continue_steps_if_needed=False)
def test_full_move(self):
current_time = TimePrototype.get_current_time()
while self.hero.position.place is None or self.hero.position.place.id != self.p3.id:
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertEqual(self.hero.actions.current_action.TYPE, prototypes.ActionInPlacePrototype.TYPE)
self.storage._test_save()
def check_companion_healing_by_hero(self, companion_type):
current_time = TimePrototype.get_current_time()
self.hero.companion.health = 1
with self.check_delta(lambda: self.hero.companion.health, c.COMPANIONS_HEALTH_PER_HEAL+c.COMPANIONS_REGEN_BY_HERO):
self.companion_record.type = companion_type
self.action_heal_companion.state = self.action_heal_companion.STATE.PROCESSED
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
def test_companion_healing_by_hero__not_healed(self):
current_time = TimePrototype.get_current_time()
self.hero.companion.health = 1
with self.check_delta(lambda: self.hero.companion.health,
c.COMPANIONS_HEALTH_PER_HEAL):
self.action_heal_companion.state = self.action_heal_companion.STATE.PROCESSED
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
def test_lighting_when_mob_killed(self):
current_time = TimePrototype.get_current_time()
action_battle = actions_prototypes.ActionBattlePvE1x1Prototype.create(hero=self.hero, mob=mobs_storage.create_mob_for_hero(self.hero))
current_time.increment_turn()
self.storage.process_turn()
action_battle.mob.health = 0
self.assertFalse(HELP_CHOICES.LIGHTING in action_battle.help_choices)
def test_corridor(self):
# fill_empty_keys_with_fake_phrases(u'test_hero_level_companion')
result, account_id, bundle_id = register_user(uuid.uuid4().hex) # pylint: disable=W0612
self.storage = LogicStorage()
self.storage.load_account_data(AccountPrototype.get_by_id(account_id))
self.hero = self.storage.accounts_to_heroes[account_id]
self.set_hero_companion()
current_time = TimePrototype.get_current_time()
for level in xrange(1, 100):
print
print '-----------------------------------------------------------------------'
print 'process level %d\texpected turns: %d\texpected days: %.2f' % (level, f.turns_on_lvl(level), f.time_on_lvl(level)/24)
for i in xrange(f.turns_on_lvl(level)): # pylint: disable=W0612
self.storage.process_turn()
current_time.increment_turn()
# simulate user behaviour on healing companion
if self.hero.companion.health < self.hero.companion.max_health / 2:
self.hero.companion.health = self.hero.companion.max_health
self.hero.randomized_level_up()
exp_to_next_level = float(self.hero.experience) / f.exp_on_lvl(self.hero.level) * 100
exp_from_expected = float(f.total_exp_to_lvl(self.hero.level)+self.hero.experience)/f.total_exp_to_lvl(level+1)*100
exp_untaken = f.total_exp_to_lvl(level+1) - f.total_exp_to_lvl(self.hero.level) - self.hero.experience
quests_untaken = float(exp_untaken) / f.experience_for_quest(c.QUEST_AREA_RADIUS)
print u'hero level: %d\texp: %.2f%%\texp from expected: %.2f%% (%d exp, %.2f quests)\ttotal quests %d' % (self.hero.level,
exp_to_next_level,
exp_from_expected,
exp_untaken,
quests_untaken,
self.hero.statistics.quests_done)
print u'abilities: %s' % ' '.join(u'%s-%d' % (ability_id, ability.level) for ability_id, ability in self.hero.abilities.abilities.items())
print u'deaths: %d' % self.hero.statistics.pve_deaths
total_gold = f.total_gold_at_lvl(self.hero.level)
print u'total money: %d from expected %d (x%.2f)' % (self.hero.statistics.money_earned,
total_gold,
float(self.hero.statistics.money_earned) / total_gold if total_gold > 0 else 0)
total_artifacts = int(f.total_time_for_lvl(self.hero.level) / 24 * c.ARTIFACTS_LOOT_PER_DAY )
print u'total artifacts: %d from expected %d (x%.2f)' % (self.hero.statistics.artifacts_had,
total_artifacts,
float(self.hero.statistics.artifacts_had) / total_artifacts if total_artifacts > 0 else 0)
print u'power: %r from expected %r' % (self.hero.power, Power.power_to_level(self.hero.preferences.archetype.power_distribution, self.hero.level))
print u'power total: %d from expected %r (x%.2f)' % (self.hero.power.total(),
Power.power_to_level(self.hero.preferences.archetype.power_distribution, self.hero.level).total(),
float(self.hero.power.total()) / Power.power_to_level(self.hero.preferences.archetype.power_distribution, self.hero.level).total())
def test_push_message(self):
current_time = TimePrototype.get_current_time()
self.messages.push_message(self.create_message('1'))
self.messages.push_message(self.create_message('2'))
current_time.increment_turn()
self.messages.push_message(self.create_message('3'))
self.assertEqual([msg.message for msg in self.messages.messages], ['1', '2', '3'])
def test_full(self):
current_time = TimePrototype.get_current_time()
while len(self.hero.actions.actions_list) != 1:
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertTrue(self.action_idl.leader)
self.storage._test_save()
def test_full_battle(self):
current_time = TimePrototype.get_current_time()
while len(self.hero.actions.actions_list) != 1:
self.storage.process_turn()
current_time.increment_turn()
self.assertTrue(self.action_idl.leader)
self.storage._test_save()
