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(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 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 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 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 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 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(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 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 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 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 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 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 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())
