def create_person(place, race, type, utg_name, gender, personality_cosmetic=None, personality_practical=None): if personality_cosmetic is None: personality_cosmetic = relations.PERSONALITY_COSMETIC.random() if personality_practical is None: personality_practical = relations.PERSONALITY_PRACTICAL.random() person = objects.Person( id=None, created_at_turn=TimePrototype.get_current_turn_number(), updated_at_turn=TimePrototype.get_current_turn_number(), updated_at=datetime.datetime.now(), place_id=place.id, gender=gender, race=race, type=type, attrs=attributes.Attributes(), personality_cosmetic=personality_cosmetic, personality_practical=personality_practical, politic_power=PersonPoliticPower.create(), utg_name=utg_name, job=PersonJob.create(normal_power=NORMAL_PERSON_JOB_POWER), moved_at_turn=TimePrototype.get_current_turn_number()) person.refresh_attributes() place.refresh_attributes() save_person(person, new=True) return person
def create_person(place, race, type, utg_name, gender, personality_cosmetic=None, personality_practical=None): if personality_cosmetic is None: personality_cosmetic = relations.PERSONALITY_COSMETIC.random() if personality_practical is None: personality_practical = relations.PERSONALITY_PRACTICAL.random() person = objects.Person( id=None, created_at_turn=TimePrototype.get_current_turn_number(), updated_at_turn=TimePrototype.get_current_turn_number(), updated_at=datetime.datetime.now(), place_id=place.id, gender=gender, race=race, type=type, attrs=attributes.Attributes(), personality_cosmetic=personality_cosmetic, personality_practical=personality_practical, politic_power=PersonPoliticPower.create(), utg_name=utg_name, job=PersonJob.create(normal_power=NORMAL_PERSON_JOB_POWER), moved_at_turn=TimePrototype.get_current_turn_number(), ) person.refresh_attributes() place.refresh_attributes() save_person(person, new=True) return person
def test_sync_data__power_from_bonuses_2(self): person_1 = self.p1.persons[0] self.assertEqual(self.p1.power, 0) self.assertEqual(person_1.power, 0) person_1.push_power(TimePrototype.get_current_turn_number(), 10000) self.p1.push_power(TimePrototype.get_current_turn_number(), 10000) self.worker.process_change_power( person_id=person_1.id, power_delta=-1000, place_id=None, positive_bonus=0, negative_bonus=0 ) self.worker.sync_data() self.assertEqual(self.p1.power, 10000 - 1000 * 2 * 1.5) self.assertEqual(person_1.power, 10000 - 1000 * 2) self.worker.process_change_power( place_id=self.p1.id, power_delta=100, person_id=None, positive_bonus=0, negative_bonus=0 ) self.worker.sync_data() self.assertEqual(self.p1.power, 10000 - 1000 * 2 * 1.5 + 100 * 1.25) self.assertEqual(person_1.power, 10000 - 1000 * 2)
def process_next_turn(self, turn_number): self.turn_number += 1 if turn_number != self.turn_number: raise LogicException( 'dessinchonization: workers turn number (%d) not equal to command turn number (%d)' % (self.turn_number, turn_number)) if TimePrototype.get_current_turn_number() != self.turn_number: raise LogicException( 'dessinchonization: workers turn number (%d) not equal to saved turn number (%d)' % (self.turn_number, TimePrototype.get_current_turn_number())) self.storage.process_turn(logger=self.logger) self.storage.save_changed_data(logger=self.logger) for hero_id in self.storage.skipped_heroes: hero = self.storage.heroes[hero_id] if hero.actions.current_action.bundle_id in self.storage.ignored_bundles: continue environment.workers.supervisor.cmd_account_release_required( hero.account_id) environment.workers.supervisor.cmd_answer('next_turn', self.worker_id) if game_settings.COLLECT_GARBAGE and self.turn_number % game_settings.COLLECT_GARBAGE_PERIOD == 0: self.logger.info('GC: start') gc.collect() self.logger.info('GC: end')
def use(self, task, storage, highlevel=None, **kwargs): # pylint: disable=R0911,W0613 place_id = task.data.get('place_id') if place_id not in places_storage: return task.logic_result(next_step=UseCardTask.STEP.ERROR, message=u'Город не найден.') if task.step.is_LOGIC: return task.logic_result(next_step=UseCardTask.STEP.HIGHLEVEL) elif task.step.is_HIGHLEVEL: place = places_storage[place_id] if self.BONUS > 0: place.push_power_positive( TimePrototype.get_current_turn_number(), self.BONUS) else: place.push_power_negative( TimePrototype.get_current_turn_number(), -self.BONUS) place.save() places_storage.update_version() return task.logic_result()
def create_place(x, y, size, utg_name, race, is_frontier=False): place = objects.Place(id=None, x=x, y=y, updated_at=datetime.datetime.now(), updated_at_turn=TimePrototype.get_current_turn_number(), created_at=datetime.datetime.now(), created_at_turn=TimePrototype.get_current_turn_number(), habit_honor=habits.Honor(raw_value=0), habit_honor_positive=0, habit_honor_negative=0, habit_peacefulness=habits.Peacefulness(raw_value=0), habit_peacefulness_positive=0, habit_peacefulness_negative=0, is_frontier=is_frontier, description='', race=race, persons_changed_at_turn=TimePrototype.get_current_turn_number(), politic_power=PlacePoliticPower.create(), attrs=attributes.Attributes(size=size), utg_name=utg_name, races=races.Races(), nearest_cells=[], effects=EffectsContainer(), job=PlaceJob.create(normal_power=NORMAL_PLACE_JOB_POWER), modifier=modifiers.CITY_MODIFIERS.NONE) place.refresh_attributes() save_place(place, new=True) return place
def create_place(self, x, y, size, roads_to, persons=(), name_forms=None, is_frontier=False): # pylint: disable=R0914 place_power = int(max(place.power for place in places_storage.all()) * float(size) / places_settings.MAX_SIZE) place_power_steps = int(places_settings.POWER_HISTORY_LENGTH / c.MAP_SYNC_TIME) place_power_per_step = (place_power / place_power_steps) + 1 place = PlacePrototype.create( x=x, y=y, utg_name=name_forms.word, is_frontier=is_frontier, size=size) initial_turn = TimePrototype.get_current_turn_number() - places_settings.POWER_HISTORY_LENGTH for i in xrange(place_power_steps): place.push_power(int(initial_turn+i*c.MAP_SYNC_TIME), int(place_power_per_step)) for person_name_forms, power_percent, race, gender, tp in persons: person = PersonPrototype.create(place=place, race=race, gender=gender, tp=tp, name_forms=person_name_forms) person_power = place_power * power_percent person_power_steps = int(persons_conf.settings.POWER_HISTORY_LENGTH / c.MAP_SYNC_TIME) person_power_per_step = (person_power / person_power_steps) + 1 initial_turn = TimePrototype.get_current_turn_number() - persons_conf.settings.POWER_HISTORY_LENGTH for i in xrange(person_power_steps): person.push_power(int(initial_turn+i*c.MAP_SYNC_TIME), int(person_power_per_step)) person.save() place.sync_persons(force_add=True) power_delta = self.INITIAL_PERSON_POWER for person in place.persons: person.fill_power_evenly(power_delta) person.save() power_delta /= 2 place.sync_race() place.save() for destination in roads_to: Road.objects.create(point_1=place._model, point_2=destination._model) persons_storage.update_version() places_storage.update_version() roads_storage.update_version() persons_storage.refresh() places_storage.refresh() roads_storage.refresh() return place
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 apply(self): if not self.state.is_VOTING: raise exceptions.ApplyBillInWrongStateError(bill_id=self.id) if not self.approved_by_moderator: raise exceptions.ApplyUnapprovedBillError(bill_id=self.id) if self.time_before_voting_end != datetime.timedelta(seconds=0): raise exceptions.ApplyBillBeforeVoteWasEndedError(bill_id=self.id) self.recalculate_votes() self._model.min_votes_percents_required = bills_settings.MIN_VOTES_PERCENT results_text = 'Итоги голосования: %d «за», %d «против» (итого %.1f%% «за»), %d «воздержалось».' % (self.votes_for, self.votes_against, round(self.votes_for_percents, 3)*100, self.votes_refrained) self._model.voting_end_at = datetime.datetime.now() self.applyed_at_turn = TimePrototype.get_current_turn_number() with transaction.atomic(): if self.is_percents_barier_not_passed: self.state = BILL_STATE.REJECTED self.save() PostPrototype.create(ThreadPrototype(self._model.forum_thread), get_system_user(), 'Законопроект отклонён.\n\n%s' % results_text, technical=True) signals.bill_processed.send(self.__class__, bill=self) return False self.data.apply(self) self.state = BILL_STATE.ACCEPTED with achievements_storage.verify(type=ACHIEVEMENT_TYPE.POLITICS_ACCEPTED_BILLS, object=self.owner): self.save() PostPrototype.create(ThreadPrototype(self._model.forum_thread), get_system_user(), 'Законопроект принят. Изменения вступят в силу в ближайшее время.\n\n%s' % results_text, technical=True) for actor in self.data.actors: if isinstance(actor, places_objects.Place): actor.effects.add(effects.Effect(name='закон №{}'.format(self.id), attribute=places_relations.ATTRIBUTE.STABILITY, value=-self.type.stability)) logic.initiate_actual_bills_update(self._model.owner_id) signals.bill_processed.send(self.__class__, bill=self) return True
def process_turn(self, logger=None, continue_steps_if_needed=True): self.switch_caches() timestamp = time.time() turn_number = TimePrototype.get_current_turn_number() processed_heroes = 0 for hero in self.heroes.values(): if hero.actions.current_action.bundle_id in self.ignored_bundles: continue if hero.id in self.skipped_heroes: continue if not hero.can_process_turn(turn_number): continue self.process_turn__single_hero(hero=hero, logger=logger, continue_steps_if_needed=continue_steps_if_needed) processed_heroes += 1 if conf.game_settings.UNLOAD_OBJECTS: hero.unload_serializable_items(timestamp) if logger: logger.info('[next_turn] processed heroes: %d / %d' % (processed_heroes, len(self.heroes))) if self.ignored_bundles: logger.info('[next_turn] ignore bundles: %r' % list(self.ignored_bundles))
def process_rare_operations(self): from the_tale.accounts.achievements.storage import achievements_storage from the_tale.accounts.achievements.relations import ACHIEVEMENT_TYPE from the_tale.game.companions import storage as companions_storage from the_tale.game.companions import logic as companions_logic current_turn = TimePrototype.get_current_turn_number() passed_interval = current_turn - self.last_rare_operation_at_turn if passed_interval < heroes_settings.RARE_OPERATIONS_INTERVAL: return if self.companion is None and random.random( ) < float(passed_interval ) / c.TURNS_IN_HOUR / c.COMPANIONS_GIVE_COMPANION_AFTER: companions_choices = [ companion for companion in companions_storage.companions.enabled_companions() if any(ability.effect.TYPE.is_LEAVE_HERO for ability in companion.abilities.start) ] if companions_choices: self.set_companion( companions_logic.create_companion( random.choice(companions_choices))) self.quests.sync_interfered_persons() with achievements_storage.verify(type=ACHIEVEMENT_TYPE.TIME, object=self): self.last_rare_operation_at_turn = current_turn
def apply(self): if not self.state.is_VOTING: raise exceptions.ApplyBillInWrongStateError(bill_id=self.id) if not self.approved_by_moderator: raise exceptions.ApplyUnapprovedBillError(bill_id=self.id) if self.time_before_voting_end != datetime.timedelta(seconds=0): raise exceptions.ApplyBillBeforeVoteWasEndedError(bill_id=self.id) self.recalculate_votes() self._model.min_votes_percents_required = bills_settings.MIN_VOTES_PERCENT results_text = u'Итоги голосования: %d «за», %d «против» (итого %.1f%% «за»), %d «воздержалось».' % ( self.votes_for, self.votes_against, round(self.votes_for_percents, 3) * 100, self.votes_refrained) self._model.voting_end_at = datetime.datetime.now() self.applyed_at_turn = TimePrototype.get_current_turn_number() if self.is_percents_barier_not_passed: self.state = BILL_STATE.REJECTED self.save() PostPrototype.create(ThreadPrototype(self._model.forum_thread), get_system_user(), u'Законопроект отклонён.\n\n%s' % results_text, technical=True) signals.bill_processed.send(self.__class__, bill=self) return False self.data.apply(self) self.state = BILL_STATE.ACCEPTED with achievements_storage.verify( type=ACHIEVEMENT_TYPE.POLITICS_ACCEPTED_BILLS, object=self.owner): self.save() PostPrototype.create( ThreadPrototype(self._model.forum_thread), get_system_user(), u'Законопроект принят. Изменения вступят в силу в ближайшее время.\n\n%s' % results_text, technical=True) for actor in self.data.actors: if isinstance(actor, PlacePrototype): actor.stability_modifiers.append( (u'закон №%d' % self.id, -self.type.stability)) logic.initiate_actual_bills_update(self._model.owner_id) signals.bill_processed.send(self.__class__, bill=self) return True
def create(cls, owner, caption, rationale, bill, chronicle_on_accepted): model = Bill.objects.create(owner=owner._model, type=bill.type, caption=caption, rationale=rationale, created_at_turn=TimePrototype.get_current_turn_number(), technical_data=s11n.to_json(bill.serialize()), state=BILL_STATE.VOTING, chronicle_on_accepted=chronicle_on_accepted, votes_for=1) # author always wote for bill bill_prototype = cls(model) text = u'Обсуждение [url="%s%s"]закона[/url]' % (project_settings.SITE_URL, reverse('game:bills:show', args=[model.id]) ) thread = ThreadPrototype.create(SubCategoryPrototype.get_by_uid(bills_settings.FORUM_CATEGORY_UID), caption=caption, author=get_system_user(), text=bill_prototype.bill_info_text(text), technical=True, markup_method=MARKUP_METHOD.POSTMARKUP) model.forum_thread = thread._model model.save() ActorPrototype.update_actors(bill_prototype, bill_prototype.data.actors) VotePrototype.create(owner, bill_prototype, VOTE_TYPE.FOR) signals.bill_created.send(sender=cls, bill=bill_prototype) return bill_prototype
def create(cls, subcategory, caption, author, text, markup_method=MARKUP_METHOD.POSTMARKUP, technical=False): from the_tale.post_service.prototypes import MessagePrototype from the_tale.post_service.message_handlers import ForumThreadHandler if isinstance(subcategory, int): subcategory = SubCategoryPrototype.get_by_id(subcategory) thread_model = Thread.objects.create(subcategory=subcategory._model, caption=caption, author=author._model, last_poster=author._model, technical=technical, posts_count=0) Post.objects.create(thread=thread_model, author=author._model, markup_method=markup_method, technical=technical, text=text, created_at_turn=TimePrototype.get_current_turn_number(), state=POST_STATE.DEFAULT) prototype = cls(model=thread_model) subcategory.update() MessagePrototype.create(ForumThreadHandler(thread_id=prototype.id)) return prototype
def create_message(self, message, turn_delta=0, time_delta=0, position=u'some position info'): return messages.MessageSurrogate(turn_number=TimePrototype.get_current_turn_number() + turn_delta, timestamp=time.time() + time_delta, key=None, externals=None, message=message, position=position)
def add_power_evenly(self, delta): cells_number = len(self.power_points) turn_number = TimePrototype.get_current_turn_number() self.power_points[:] = [ (turn, value+delta/cells_number / (1 - float(turn_number- turn) / history_length)) for turn, value in self.power_points ]
def create_message(self, uid): return heroes_messages.MessageSurrogate(turn_number=TimePrototype.get_current_turn_number(), timestamp=time.time(), key=None, externals=None, message='message {}'.format(uid), position='position {}'.format(uid))
def create_building(person, utg_name, position=None): from the_tale.game.places import storage from . import logic building = storage.buildings.get_by_person_id(person.id) if building: return building # remove any destroyed buildings for person models.Building.objects.filter(person_id=person.id).delete() if position is None: position = random.choice(list(get_available_positions(person.place.x, person.place.y))) x, y = position building = objects.Building(id=None, x=x, y=y, type=person.type.building_type, integrity=1.0, created_at_turn=TimePrototype.get_current_turn_number(), state=relations.BUILDING_STATE.WORKING, utg_name=utg_name, person_id=person.id) save_building(building, new=True) return building
def update(self, text): self._model.text = text self._model.updated_at_turn = TimePrototype.get_current_turn_number() self.save() self.thread.update() self.thread.subcategory.update()
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 can_be_helped(self): if (self.last_help_on_turn == TimePrototype.get_current_turn_number() and self.helps_in_turn >= conf.heroes_settings.MAX_HELPS_IN_TURN): return False return True
def test_initialize(self): self.assertEqual(self.person.place.persons_changed_at_turn, self.persons_changed_at_turn) self.assertEqual(self.person.friends_number, 0) self.assertEqual(self.person.enemies_number, 0) self.assertEqual(self.person.created_at_turn, TimePrototype.get_current_turn_number() - 1) self.assertTrue(self.person.is_stable)
def process_next_turn(self, turn_number): self.turn_number += 1 if turn_number != self.turn_number: raise LogicException('dessinchonization: workers turn number (%d) not equal to command turn number (%d)' % (self.turn_number, turn_number)) if TimePrototype.get_current_turn_number() != self.turn_number: raise LogicException('dessinchonization: workers turn number (%d) not equal to saved turn number (%d)' % (self.turn_number, TimePrototype.get_current_turn_number())) self.storage.process_turn(logger=self.logger) self.storage.save_changed_data(logger=self.logger) for hero_id in self.storage.skipped_heroes: hero = self.storage.heroes[hero_id] if hero.actions.current_action.bundle_id in self.storage.ignored_bundles: continue environment.workers.supervisor.cmd_account_release_required(hero.account_id) environment.workers.supervisor.cmd_answer('next_turn', self.worker_id) if game_settings.COLLECT_GARBAGE and self.turn_number % game_settings.COLLECT_GARBAGE_PERIOD == 0: self.logger.info('GC: start') gc.collect() self.logger.info('GC: end')
def create(cls, person, utg_name): from the_tale.game.places import storage building = storage.buildings.get_by_person_id(person.id) if building: return building # remove any destroyed buildings for person cls._model_class.objects.filter(person_id=person.id).delete() x, y = random.choice(list(cls.get_available_positions(person.place.x, person.place.y))) model = models.Building.objects.create(x=x, y=y, data=s11n.to_json({'name': utg_name.serialize()}), place_id=person.place_id, person_id=person.id, state=relations.BUILDING_STATE.WORKING, created_at_turn=TimePrototype.get_current_turn_number(), type=person.type.building_type) prototype = cls(model=model) storage.buildings.add_item(prototype.id, prototype) storage.buildings.update_version() return prototype
def create(cls, person, utg_name): from the_tale.game.places import storage building = storage.buildings.get_by_person_id(person.id) if building: return building # remove any destroyed buildings for person cls._model_class.objects.filter(person_id=person.id).delete() x, y = random.choice( list(cls.get_available_positions(person.place.x, person.place.y))) model = models.Building.objects.create( x=x, y=y, data=s11n.to_json({'name': utg_name.serialize()}), place_id=person.place_id, person_id=person.id, state=relations.BUILDING_STATE.WORKING, created_at_turn=TimePrototype.get_current_turn_number(), type=person.type.building_type) prototype = cls(model=model) storage.buildings.add_item(prototype.id, prototype) storage.buildings.update_version() return prototype
def ui_info(self, actual_guaranteed, old_info=None): from the_tale.game.map.generator.drawer import get_hero_sprite new_info = {'id': self.id, 'patch_turn': None if old_info is None else old_info['actual_on_turn'], 'actual_on_turn': TimePrototype.get_current_turn_number() if actual_guaranteed else self.saved_at_turn, 'ui_caching_started_at': time.mktime(self.ui_caching_started_at.timetuple()), 'diary': None, # diary version will be setupped by game:info view 'messages': self.journal.ui_info(), 'position': self.position.ui_info(), 'bag': self.bag.ui_info(self), 'equipment': self.equipment.ui_info(self), 'cards': self.cards.ui_info(), 'might': { 'value': self.might, 'crit_chance': self.might_crit_chance, 'pvp_effectiveness_bonus': self.might_pvp_effectiveness_bonus, 'politics_power': self.politics_power_might }, 'permissions': { 'can_participate_in_pvp': self.can_participate_in_pvp, 'can_repair_building': self.can_repair_building }, 'energy': { 'max': self.energy_maximum, 'value': self.energy, 'bonus': self.energy_bonus, 'discount': self.energy_discount}, 'action': self.actions.current_action.ui_info(), 'companion': self.companion.ui_info() if self.companion else None, 'base': { 'name': self.name, 'level': self.level, 'destiny_points': self.abilities.destiny_points, 'health': int(self.health), 'max_health': int(self.max_health), 'experience': int(self.experience), 'experience_to_level': int(self.experience_to_next_level), 'gender': self.gender.value, 'race': self.race.value, 'money': self.money, 'alive': self.is_alive}, 'secondary': { 'power': self.power.ui_info(), 'move_speed': float(self.move_speed), 'initiative': self.initiative, 'max_bag_size': self.max_bag_size, 'loot_items_count': self.bag.occupation}, 'habits': { game_relations.HABIT_TYPE.HONOR.verbose_value: {'verbose': self.habit_honor.verbose_value, 'raw': self.habit_honor.raw_value}, game_relations.HABIT_TYPE.PEACEFULNESS.verbose_value: {'verbose': self.habit_peacefulness.verbose_value, 'raw': self.habit_peacefulness.raw_value}}, 'quests': self.quests.ui_info(self), 'sprite': get_hero_sprite(self).value, } changed_fields = ['changed_fields', 'actual_on_turn', 'patch_turn'] if old_info: for key, value in new_info.items(): if old_info[key] != value: changed_fields.append(key) new_info['changed_fields'] = changed_fields return new_info
def test_buy_meal(self): self.hero.position.last_place_visited_turn = TimePrototype.get_current_turn_number() - c.TURNS_IN_HOUR * 12 with contextlib.nested( self.check_decreased(lambda: self.hero.money), self.check_delta(lambda: self.hero.statistics.money_spend_for_companions, int(f.expected_gold_in_day(self.hero.level) / 2 * 0.5) + 1), self.check_increased(lambda: len(self.hero.messages)) ): prototypes.ActionInPlacePrototype.create(hero=self.hero)
def test_not_enough_money(self): self.hero.position.last_place_visited_turn = TimePrototype.get_current_turn_number() - 1 with contextlib.nested( self.check_delta(lambda: self.hero.money, -self.hero.money), self.check_delta(lambda: self.hero.statistics.money_spend_for_companions, self.hero.money), self.check_increased(lambda: len(self.hero.messages)) ): prototypes.ActionInPlacePrototype.create(hero=self.hero)
def create(cls, key, externals, turn_delta=0, restrictions=frozenset(), position=u''): return cls(turn_number=TimePrototype.get_current_turn_number()+turn_delta, timestamp=time.time()+turn_delta*c.TURN_DELTA, key=key, externals=externals, message=None, restrictions=restrictions, position=position)
def _start_quest(self, start, hero): hero.quests.update_history(start.type, TimePrototype.get_current_turn_number()) self.quests_stack.append( QuestInfo.construct(type=start.type, uid=start.uid, knowledge_base=self.machine.knowledge_base, hero=hero))
def create_message(self, uid): return heroes_messages.MessageSurrogate( turn_number=TimePrototype.get_current_turn_number(), timestamp=time.time(), key=None, externals=None, message='message {}'.format(uid), position='position {}'.format(uid))
def _start_quest(self, start, hero): hero.quests.update_history(start.type, TimePrototype.get_current_turn_number()) self.quests_stack.append(QuestInfo.construct(type=start.type, uid=start.uid, knowledge_base=self.machine.knowledge_base, experience=self.get_expirience_for_quest(start.uid, hero), power=self.get_politic_power_for_quest(start.uid, hero), hero=hero))
def on_help(self): current_turn = TimePrototype.get_current_turn_number() if self.last_help_on_turn != current_turn: self.last_help_on_turn = current_turn self.helps_in_turn = 0 self.helps_in_turn += 1
def create_fake(cls, key, externals, turn_delta=0, restrictions=frozenset(), position=u''): from the_tale.linguistics.logic import fake_text return cls(turn_number=TimePrototype.get_current_turn_number()+turn_delta, timestamp=time.time()+turn_delta*c.TURN_DELTA, key=None, externals=externals, message=fake_text(key, externals), restrictions=restrictions, position=position)
def create(cls, normal_power): effect = random.choice([effect for effect in effects.EFFECT.records if effect.group.is_ON_HEROES]) return cls(name=cls.create_name(effect), created_at_turn=TimePrototype.get_current_turn_number(), effect=effect, positive_power=0, negative_power=0, power_required=normal_power * effect.power_modifier)
def save_place(place, new=False): from the_tale.game.places import storage data = { 'name': place.utg_name.serialize(), 'attributes': place.attrs.serialize(), 'races': place.races.serialize(), 'nearest_cells': place.nearest_cells, 'effects': place.effects.serialize(), 'job': place.job.serialize(), 'politic_power': place.politic_power.serialize() } arguments = { 'x': place.x, 'y': place.y, 'updated_at_turn': TimePrototype.get_current_turn_number(), 'updated_at': datetime.datetime.now(), 'is_frontier': place.is_frontier, 'description': place.description, 'data': s11n.to_json(data), 'habit_honor_positive': place.habit_honor_positive, 'habit_honor_negative': place.habit_honor_negative, 'habit_peacefulness_positive': place.habit_peacefulness_positive, 'habit_peacefulness_negative': place.habit_peacefulness_negative, 'habit_honor': place.habit_honor.raw_value, 'habit_peacefulness': place.habit_peacefulness.raw_value, 'modifier': place._modifier, 'race': place.race, 'persons_changed_at_turn': place.persons_changed_at_turn } if new: place_model = models.Place.objects.create( created_at_turn=TimePrototype.get_current_turn_number(), **arguments) place.id = place_model.id storage.places.add_item(place.id, place) else: models.Place.objects.filter(id=place.id).update(**arguments) storage.places.update_version() place.updated_at = datetime.datetime.now()
def new_job(self, effect, normal_power): if self.positive_power > self.negative_power: self.positive_power = 0 else: self.negative_power = 0 self.name = self.create_name(effect) self.created_at_turn = TimePrototype.get_current_turn_number() self.effect = effect self.power_required = normal_power * effect.power_modifier
def test_buy_meal(self): self.hero.position.last_place_visited_turn = TimePrototype.get_current_turn_number( ) - c.TURNS_IN_HOUR * 12 with contextlib.nested( self.check_decreased(lambda: self.hero.money), self.check_delta( lambda: self.hero.statistics.money_spend_for_companions, int(f.expected_gold_in_day(self.hero.level) / 2 * 0.5) + 1), self.check_increased(lambda: len(self.hero.messages))): prototypes.ActionInPlacePrototype.create(hero=self.hero)
def test_not_enough_money(self): self.hero.position.last_place_visited_turn = TimePrototype.get_current_turn_number( ) - 1 with contextlib.nested( self.check_delta(lambda: self.hero.money, -self.hero.money), self.check_delta( lambda: self.hero.statistics.money_spend_for_companions, self.hero.money), self.check_increased(lambda: len(self.hero.messages))): prototypes.ActionInPlacePrototype.create(hero=self.hero)
def move_out_game(self): self._model.out_game_at = datetime.datetime.now() self._model.state = PERSON_STATE.OUT_GAME self.place.persons_changed_at_turn = TimePrototype.get_current_turn_number() building = buildings_storage.get_by_person_id(self.id) if building: building.destroy()
def create(cls, place, race, tp, utg_name, gender, state=None): from the_tale.game.persons.storage import persons_storage instance = Person.objects.create(place=place._model, state=state if state is not None else PERSON_STATE.IN_GAME, race=race, type=tp, gender=gender, name=utg_name.normal_form(), data=s11n.to_json({'name': utg_name.serialize()}), created_at_turn=TimePrototype.get_current_turn_number()) prototype = cls(model=instance) persons_storage.add_item(prototype.id, prototype) persons_storage.update_version() prototype.place.persons_changed_at_turn = TimePrototype.get_current_turn_number() return prototype
def move_out_game(self): self._model.out_game_at = datetime.datetime.now() self._model.state = PERSON_STATE.OUT_GAME self.place.persons_changed_at_turn = TimePrototype.get_current_turn_number( ) building = buildings_storage.get_by_person_id(self.id) if building: building.destroy()
def _start_quest(self, start, hero): hero.quests.update_history(start.type, TimePrototype.get_current_turn_number()) self.quests_stack.append( QuestInfo.construct( type=start.type, uid=start.uid, knowledge_base=self.machine.knowledge_base, experience=self.get_expirience_for_quest(start.uid, hero), power=self.get_politic_power_for_quest(start.uid, hero), hero=hero))
def ui_info(self, with_info=False): current_turn = TimePrototype.get_current_turn_number() messages = [] for message in self.messages: if message.turn_number > current_turn: break messages.append(message.ui_info(with_info=with_info)) return messages
def create(cls, place_id, road_id): return cls(last_place_visited_turn=TimePrototype.get_current_turn_number(), moved_out_place=False, place_id=place_id, road_id=road_id, previous_place_id=None, invert_direction=False, percents=0, from_x=None, from_y=None, to_x=None, to_y=None)
def push_power(self, turn, value): points = getattr(self, name) if points and points[-1][0] > turn: raise exception_class(message=u'can not push power to place "%s" - current push turn number (%d) less then latest (%d) ' % (self.name, points[-1][0], turn)) points.append((turn, value)) current_turn_number = TimePrototype.get_current_turn_number() while points and points[0][0] < current_turn_number - history_length: points.pop(0)
def is_stable(self): if self.created_at_turn > TimePrototype.get_current_turn_number() - persons_conf.settings.POWER_STABILITY_WEEKS*7*24*c.TURNS_IN_HOUR: return True total_persons_power = self.place.total_persons_power power_percent = float(self.power) / total_persons_power if total_persons_power > 0.0001 else 0.0 if power_percent > persons_conf.settings.POWER_STABILITY_PERCENT: return True return False
def hero_position_from_model(hero_model): return position.Position(last_place_visited_turn=TimePrototype.get_current_turn_number(), # TODO: get from model moved_out_place=False, # TODO: get from model place_id=hero_model.pos_place_id, road_id=hero_model.pos_road_id, previous_place_id=hero_model.pos_previous_place_id, invert_direction=hero_model.pos_invert_direction, percents=hero_model.pos_percents, from_x=hero_model.pos_from_x, from_y=hero_model.pos_from_y, to_x=hero_model.pos_to_x, to_y=hero_model.pos_to_y)
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())