def sync_data(self, sheduled=True):
self.logger.info('sync data')
all_persons = persons_storage.persons_storage.filter(state=PERSON_STATE.IN_GAME)
self.sync_persons_powers(persons=[person for person in all_persons if person.place.is_frontier])
self.sync_persons_powers(persons=[person for person in all_persons if not person.place.is_frontier])
for person in all_persons:
person.update_friends_number()
person.update_enemies_number()
self.persons_power = {}
self.sync_places_powers(places=[place for place in places_storage.all() if place.is_frontier])
self.sync_places_powers(places=[place for place in places_storage.all() if not place.is_frontier])
self.places_power = {}
# update size
if sheduled:
self.sync_sizes([place for place in places_storage.all() if place.is_frontier],
hours=c.MAP_SYNC_TIME_HOURS,
max_size=places_settings.MAX_FRONTIER_SIZE)
self.sync_sizes([place for place in places_storage.all() if not place.is_frontier],
hours=c.MAP_SYNC_TIME_HOURS,
max_size=places_settings.MAX_SIZE)
for place in places_storage.all():
place.sync_stability()
place.sync_modifier()
place.sync_habits()
place.sync_parameters() # must be last operation to display and use real data
place.update_heroes_number()
place.update_heroes_habits()
place.mark_as_updated()
places_storage.save_all()
persons_storage.persons_storage.remove_out_game_persons()
persons_storage.persons_storage.save_all()
persons_logic.sync_social_connections()
if sheduled:
for building in buildings_storage.all():
building.amortize(c.MAP_SYNC_TIME)
buildings_storage.save_all()
self.logger.info('sync data completed')
def setUp(self):
super(PlaceDescriptionTests, self).setUp()
self.place = places_storage.all()[0]
self.place.description = 'old description'
self.place.save()
self.place_2 = places_storage.all()[1]
self.bill_data = PlaceDescripton(place_id=self.place.id, description='new description')
self.bill = BillPrototype.create(self.account1, 'bill-1-caption', 'bill-1-rationale', self.bill_data, chronicle_on_accepted='chronicle-on-accepted')
def setUp(self):
super(PlaceDescriptionTests, self).setUp()
self.place = places_storage.all()[0]
self.place.description = 'old description'
self.place.save()
self.place_2 = places_storage.all()[1]
self.bill_data = PlaceDescripton(place_id=self.place.id, description='new description')
self.bill = BillPrototype.create(self.account1, 'bill-1-caption', 'bill-1-rationale', self.bill_data, chronicle_on_accepted='chronicle-on-accepted')
def test_sync_data__places_methods_called(self):
# all that methods tested in places package
set_expected_size = mock.Mock()
sync_size = mock.Mock()
sync_persons = mock.Mock()
sync_stability = mock.Mock()
sync_habits = mock.Mock()
sync_modifier = mock.Mock()
sync_parameters = mock.Mock()
update_heroes_number = mock.Mock()
mark_as_updated = mock.Mock()
with contextlib.nested(mock.patch('the_tale.game.map.places.prototypes.PlacePrototype.set_expected_size', set_expected_size),
mock.patch('the_tale.game.map.places.prototypes.PlacePrototype.sync_size', sync_size),
mock.patch('the_tale.game.map.places.prototypes.PlacePrototype.sync_persons', sync_persons),
mock.patch('the_tale.game.map.places.prototypes.PlacePrototype.sync_stability', sync_stability),
mock.patch('the_tale.game.map.places.prototypes.PlacePrototype.sync_habits', sync_habits),
mock.patch('the_tale.game.map.places.prototypes.PlacePrototype.sync_modifier', sync_modifier),
mock.patch('the_tale.game.map.places.prototypes.PlacePrototype.sync_parameters', sync_parameters),
mock.patch('the_tale.game.map.places.prototypes.PlacePrototype.update_heroes_number', update_heroes_number),
mock.patch('the_tale.game.map.places.prototypes.PlacePrototype.mark_as_updated', mark_as_updated)):
self.worker.sync_data()
places_number = len(places_storage.all())
self.assertEqual(set_expected_size.call_count, places_number)
self.assertEqual(sync_size.call_count, places_number)
self.assertEqual(sync_persons.call_count, places_number)
self.assertEqual(sync_stability.call_count, places_number)
self.assertEqual(sync_habits.call_count, places_number)
self.assertEqual(sync_modifier.call_count, places_number)
self.assertEqual(sync_parameters.call_count, places_number)
self.assertEqual(update_heroes_number.call_count, places_number)
self.assertEqual(mark_as_updated.call_count, places_number)
def _point_arrow_height(obj, borders, length_normalizer, width_normalizer, power_percent):
distances = []
for other_place in places_storage.all():
if obj.id != other_place.id:
distances.append((math.hypot(obj.x - other_place.x, obj.y - other_place.y), other_place))
distances = sorted(distances, key=lambda x: x[0])
arrows = []
if len(distances) > 0:
distance, other_place = distances[0] # pylint: disable=W0612
arrow = power_points.ArrowAreaPoint.Arrow(angle=math.atan2(other_place.y - obj.y, other_place.x - obj.x),
length=obj.r,
width=(obj.r / 3) + 1)
arrows.extend([arrow, arrow.rounded_arrow])
if len(distances) > 1:
distance, other_place = distances[1]
arrow = power_points.ArrowAreaPoint.Arrow(angle=math.atan2(other_place.y - obj.y, other_place.x - obj.x),
length=obj.r,
width=(obj.r / 3) + 1)
arrows.extend([arrow, arrow.rounded_arrow])
return power_points.ArrowAreaPoint(layer_type=layers.LAYER_TYPE.HEIGHT,
name='height_arrow_' + obj.uid,
x=obj.x,
y=obj.y,
power=get_height_power_function(borders, power_percent),
default_power=(0.0, 0.0),
length_normalizer=length_normalizer,
width_normalizer=width_normalizer,
arrows=arrows)
def fill_places(kb, hero_info, max_distance):
places = []
for place in places_storage.all():
path_length = waymarks_storage.look_for_road(
places_storage[hero_info.position_place_id], place).length
if path_length > max_distance:
continue
places.append((path_length, place))
places.sort()
chosen_places = []
for base_distance, place in places:
for chosen_place in chosen_places:
path_length = waymarks_storage.look_for_road(chosen_place,
place).length
if path_length > max_distance:
break
else:
chosen_places.append(place)
for place in chosen_places:
uid = uids.place(place.id)
if uid in kb:
continue
kb += fact_place(place)
def fill_places(kb, hero_info, max_distance):
places = []
for place in places_storage.all():
path_length = waymarks_storage.look_for_road(places_storage[hero_info.position_place_id], place).length
if path_length > max_distance:
continue
places.append((path_length, place))
places.sort()
chosen_places = []
for base_distance, place in places:
for chosen_place in chosen_places:
path_length = waymarks_storage.look_for_road(chosen_place, place).length
if path_length > max_distance:
break
else:
chosen_places.append(place)
for place in chosen_places:
uid = uids.place(place.id)
if uid in kb:
continue
kb += fact_place(place)
def get_quests_priorities(self):
# always check hero position to prevent «bad» quests generation
from the_tale.game.quests.relations import QUESTS
quests = [
quest for quest in QUESTS.records if quest.quest_type.is_NORMAL
]
if self.preferences.mob is not None:
quests.append(QUESTS.HUNT)
if self.preferences.place is not None and (
self.position.place is None
or self.preferences.place.id != self.position.place.id):
quests.append(QUESTS.HOMETOWN)
if self.preferences.friend is not None and (
self.position.place is None
or self.preferences.friend.place.id != self.position.place.id):
quests.append(QUESTS.HELP_FRIEND)
if self.preferences.enemy is not None and (
self.position.place is None
or self.preferences.enemy.place.id != self.position.place.id):
quests.append(QUESTS.INTERFERE_ENEMY)
if any(place.modifier and place.modifier.TYPE.is_HOLY_CITY
for place in places_storage.all()):
if self.position.place is None or self.position.place.modifier is None or not self.position.place.modifier.TYPE.is_HOLY_CITY:
quests.append(QUESTS.PILGRIMAGE)
return [(quest, self.modify_quest_priority(quest)) for quest in quests]
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 form_choices(cls,
only_weak=False,
choosen_person=None,
predicate=lambda place, person: True):
choices = []
for place in places_storage.all():
persons_choices = filter(lambda person: predicate(place, person),
place.persons) # pylint: disable=W0110
accepted_persons = persons_choices[
place.max_persons_number /
2:] if only_weak else persons_choices
if choosen_person is not None and choosen_person.place.id == place.id:
if choosen_person.id not in [p.id for p in accepted_persons]:
accepted_persons.append(choosen_person)
place_power = place.total_persons_power
persons = tuple((person.id, u'%s [%s %.2f%%]' %
(person.name, person.type.text, person.power /
place_power * 100 if place_power > 0.001 else 0))
for person in accepted_persons)
persons = sorted(persons, key=lambda choice: choice[1])
choices.append((place.name, persons))
return sorted(choices, key=lambda choice: choice[0])
def test_get_neares_place(self):
for place in places_storage.all():
x, y = place.x, place.y
with mock.patch('the_tale.game.heroes.prototypes.HeroPositionPrototype.cell_coordinates', (x, y)):
self.assertEqual(place.id, self.hero.position.get_nearest_place().id)
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 get_nearest_place(self):
x, y = self.cell_coordinates
best_distance = 999999999999999
best_place = None
for place in places_storage.all():
distance = math.hypot(place.x-x, place.y-y)
if distance < best_distance:
best_distance = distance
best_place = place
return best_place
def get_nearest_place(self):
x, y = self.cell_coordinates
best_distance = 999999999999999
best_place = None
for place in places_storage.all():
distance = math.hypot(place.x - x, place.y - y)
if distance < best_distance:
best_distance = distance
best_place = place
return best_place
def update_waymarks(): # pylint: disable=R0912
places = places_storage.all()
roads = roads_storage.all_exists_roads()
places_len = len(places)
paths = [ [ Path() for place in xrange(places_len) ] for i in xrange(places_len)] # pylint: disable=W0612
p2i = dict( (place.id, i) for i, place in enumerate(places))
for i in xrange(len(places)):
paths[i][i].update_path(0, None)
for road in roads:
i = p2i[road.point_1_id]
j = p2i[road.point_2_id]
paths[i][j].update_path(road.length, road.id)
paths[j][i].update_path(road.length, road.id)
for k in xrange(places_len):
for i in xrange(places_len):
for j in xrange(places_len):
new_len = min(paths[i][j].length,
paths[i][k].length + paths[k][j].length)
paths[i][j].update_path(new_len, paths[i][k].road_id)
for row in paths:
res = []
for el in row:
res.append(el.road_id)
for i in xrange(places_len):
for j in xrange(places_len):
if paths[i][j].road_id is not None:
road = roads_storage[paths[i][j].road_id]
else:
road = None
waymark = waymarks_storage.look_for_road(point_from=places[i].id, point_to=places[j].id)
if waymark:
waymark.road = road
waymark.length = paths[i][j].length
waymark.save()
else:
waymark = WaymarkPrototype.create(point_from=places[i],
point_to=places[j],
road=road,
length=paths[i][j].length)
waymarks_storage.update_version()
def handle(self, *args, **options):
for place in places_storage.all():
place.sync_persons(force_add=True)
place.sync_habits()
place.sync_parameters() # must be last operation to display and use real data
place.update_heroes_number()
place.update_heroes_habits()
place.save()
def handle(self, *args, **options):
for place in places_storage.all():
place.sync_persons(force_add=True)
place.sync_habits()
place.sync_parameters(
) # must be last operation to display and use real data
place.update_heroes_number()
place.update_heroes_habits()
place.save()
def create(cls, turn_number, width, height, terrain, world): # pylint: disable=R0914
from the_tale.game.map.generator.descriptors import UICells
terrain_percents = {}
terrain_squares = collections.defaultdict(int)
for y in xrange(0, height):
for x in xrange(0, width):
cell = world.generator.cell_info(x, y)
if cell.height < -0.2:
terrain_squares[MAP_STATISTICS.LOWLANDS] += 1
elif cell.height < 0.3:
terrain_squares[MAP_STATISTICS.PLAINS] += 1
else:
terrain_squares[MAP_STATISTICS.UPLANDS] += 1
if cell.vegetation == VEGETATION_TYPE.DESERT:
terrain_squares[MAP_STATISTICS.DESERTS] += 1
elif cell.vegetation == VEGETATION_TYPE.GRASS:
terrain_squares[MAP_STATISTICS.GRASS] += 1
else:
terrain_squares[MAP_STATISTICS.FORESTS] += 1
total_cells = width * height
terrain_percents = dict( (id_.value, float(square) / total_cells) for id_, square in terrain_squares.items())
person_race_percents = get_person_race_percents(persons_storage.filter(state=PERSON_STATE.IN_GAME))
race_percents = get_race_percents(places_storage.all())
#race to cities percents
race_cities = dict( (race.value, 0) for race in RACE.records)
for place_model in Place.objects.all():
place = PlacePrototype(place_model)
race_cities[place.race.value] += 1
statistics = {'terrain_percents': terrain_percents,
'person_race_percents': person_race_percents,
'race_percents': race_percents,
'race_cities': race_cities}
model = MapInfo.objects.create(turn_number=turn_number,
width=width,
height=height,
terrain=s11n.to_json([ [cell.value for cell in row] for row in terrain]),
cells=s11n.to_json(UICells.create(world.generator).serialize()),
world=world._model,
statistics=s11n.to_json(statistics))
return cls(model)
def fill_places_for_first_quest(kb, hero_info):
best_distance = c.QUEST_AREA_MAXIMUM_RADIUS
best_destination = None
for place in places_storage.all():
if place.id == hero_info.position_place_id:
continue
path_length = waymarks_storage.look_for_road(places_storage[hero_info.position_place_id], place).length
if path_length < best_distance:
best_distance = path_length
best_destination = place
kb += fact_place(best_destination)
kb += fact_place(places_storage[hero_info.position_place_id])
def fill_places_for_first_quest(kb, hero_info):
best_distance = c.QUEST_AREA_MAXIMUM_RADIUS
best_destination = None
for place in places_storage.all():
if place.id == hero_info.position_place_id:
continue
path_length = waymarks_storage.look_for_road(
places_storage[hero_info.position_place_id], place).length
if path_length < best_distance:
best_distance = path_length
best_destination = place
kb += fact_place(best_destination)
kb += fact_place(places_storage[hero_info.position_place_id])
def get_available_positions(
cls,
center_x,
center_y,
building_position_radius=places_settings.BUILDING_POSITION_RADIUS): # pylint: disable=R0914
from the_tale.game.map.places.storage import places_storage, buildings_storage
from the_tale.game.map.roads.storage import roads_storage
from the_tale.game.map.roads.relations import PATH_DIRECTION
positions = set()
for i in xrange(0, building_position_radius + 1):
for j in xrange(0, building_position_radius + 1):
positions.add((center_x + i, center_y + j))
positions.add((center_x - i, center_y + j))
positions.add((center_x + i, center_y - j))
positions.add((center_x - i, center_y - j))
positions = set(pos for pos in positions
if 0 <= pos[0] < map_settings.WIDTH
and 0 <= pos[1] < map_settings.HEIGHT)
removed_positions = set()
for place in places_storage.all():
removed_positions.add((place.x, place.y))
for building in buildings_storage.all():
removed_positions.add((building.x, building.y))
for road in roads_storage.all_exists_roads():
x, y = road.point_1.x, road.point_1.y
for direction in road.path:
if direction == PATH_DIRECTION.LEFT.value: x -= 1
elif direction == PATH_DIRECTION.RIGHT.value: x += 1
elif direction == PATH_DIRECTION.UP.value: y -= 1
elif direction == PATH_DIRECTION.DOWN.value: y += 1
removed_positions.add((x, y))
result = positions - removed_positions
return result if result else cls.get_available_positions(
center_x,
center_y,
building_position_radius=building_position_radius + 1)
def get_draw_info(biomes_map):
width = map_info_storage.item.width
height = map_info_storage.item.height
map_images = []
for y in xrange(height):
map_images.append([])
for x in xrange(width):
map_images[-1].append(CellDrawer())
roads_map = get_roads_map(width, height, roads_storage.all())
for y in xrange(height):
for x in xrange(width):
biom = biomes_map[y][x]
cell_drawer = map_images[y][x]
cell_drawer.terrain = SPRITES.index_name[biom.id.name]
if roads_map[y][x]:
road_sprite = get_road_sprite_info(roads_map, x, y)
cell_drawer.road = SPRITES.index_name[road_sprite['name']]
cell_drawer.road_rotate = road_sprite['rotate']
for place in places_storage.all():
if place.size < 3: verbose_size = 'small'
elif place.size < 6: verbose_size = 'medium'
elif place.size < 9: verbose_size = 'large'
else: verbose_size = 'capital'
sprite_name = ('city_%s_%s' % (place.race.name.lower(), verbose_size)).upper()
cell_drawer = map_images[place.y][place.x]
cell_drawer.object = SPRITES.index_name[sprite_name]
for building in buildings_storage.all():
sprite_name = 'BUILDING_%s' % building.type.name
cell_drawer = map_images[building.y][building.x]
cell_drawer.object = SPRITES.index_name[sprite_name]
return map_images
def test_get_available_positions(self):
building = BuildingPrototype.create(self.place_1.persons[0],
utg_name=names.generator.get_test_name(name='building-name'))
positions = BuildingPrototype.get_available_positions(self.place_1.x, self.place_1.y)
self.assertTrue(positions)
for place in places_storage.all():
self.assertFalse((place.x, place.y) in positions)
for building in buildings_storage.all():
self.assertFalse((building.x, building.y) in positions)
for x, y in positions:
self.assertTrue(0 <= x < map_settings.WIDTH)
self.assertTrue(0 <= y < map_settings.HEIGHT)
def create_test_map():
linguistics_logic.sync_static_restrictions()
map_logic.create_test_my_info()
p1 = PlacePrototype.create( x=1, y=1, size=1, utg_name=names.generator.get_test_name(name='1x1'))
p2 = PlacePrototype.create( x=3, y=3, size=3, utg_name=names.generator.get_test_name(name='10x10'))
p3 = PlacePrototype.create( x=1, y=3, size=3, utg_name=names.generator.get_test_name(name='1x10'))
for place in places_storage.all():
place.sync_persons(force_add=True)
RoadPrototype.create(point_1=p1, point_2=p2).update()
RoadPrototype.create(point_1=p2, point_2=p3).update()
update_waymarks()
update_nearest_cells()
mob_1 = MobRecordPrototype.create_random('mob_1')
mob_2 = MobRecordPrototype.create_random('mob_2')
mob_3 = MobRecordPrototype.create_random('mob_3')
ArtifactRecordPrototype.create_random('loot_1', mob=mob_1)
ArtifactRecordPrototype.create_random('loot_2', mob=mob_2)
ArtifactRecordPrototype.create_random('loot_3', mob=mob_3)
ArtifactRecordPrototype.create_random('helmet_1', type_=ARTIFACT_TYPE.HELMET, mob=mob_1)
ArtifactRecordPrototype.create_random('plate_1', type_=ARTIFACT_TYPE.PLATE, mob=mob_2)
ArtifactRecordPrototype.create_random('boots_1', type_=ARTIFACT_TYPE.BOOTS, mob=mob_3)
ArtifactRecordPrototype.create_random(DEFAULT_HERO_EQUIPMENT.PANTS, type_=ARTIFACT_TYPE.PANTS)
ArtifactRecordPrototype.create_random(DEFAULT_HERO_EQUIPMENT.BOOTS, type_=ARTIFACT_TYPE.BOOTS)
ArtifactRecordPrototype.create_random(DEFAULT_HERO_EQUIPMENT.PLATE, type_=ARTIFACT_TYPE.PLATE)
ArtifactRecordPrototype.create_random(DEFAULT_HERO_EQUIPMENT.GLOVES, type_=ARTIFACT_TYPE.GLOVES)
ArtifactRecordPrototype.create_random(DEFAULT_HERO_EQUIPMENT.WEAPON, type_=ARTIFACT_TYPE.MAIN_HAND)
companions_logic.create_random_companion_record('companion_1', dedication=companions_relations.DEDICATION.HEROIC, state=companions_relations.STATE.ENABLED)
companions_logic.create_random_companion_record('companion_2', dedication=companions_relations.DEDICATION.BOLD, state=companions_relations.STATE.ENABLED)
companions_logic.create_random_companion_record('companion_3', dedication=companions_relations.DEDICATION.BOLD, state=companions_relations.STATE.DISABLED)
return p1, p2, p3
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 get_quests_priorities(self):
# always check hero position to prevent «bad» quests generation
from the_tale.game.quests.relations import QUESTS
quests = [quest for quest in QUESTS.records if quest.quest_type.is_NORMAL]
if self.preferences.mob is not None:
quests.append(QUESTS.HUNT)
if self.preferences.place is not None and (self.position.place is None or self.preferences.place.id != self.position.place.id):
quests.append(QUESTS.HOMETOWN)
if self.preferences.friend is not None and (self.position.place is None or self.preferences.friend.place.id != self.position.place.id):
quests.append(QUESTS.HELP_FRIEND)
if self.preferences.enemy is not None and (self.position.place is None or self.preferences.enemy.place.id != self.position.place.id):
quests.append(QUESTS.INTERFERE_ENEMY)
if any(place.modifier and place.modifier.TYPE.is_HOLY_CITY for place in places_storage.all()):
if self.position.place is None or self.position.place.modifier is None or not self.position.place.modifier.TYPE.is_HOLY_CITY:
quests.append(QUESTS.PILGRIMAGE)
return [(quest, self.modify_quest_priority(quest)) for quest in quests]
def test_get_available_positions(self):
building = BuildingPrototype.create(
self.place_1.persons[0],
utg_name=names.generator.get_test_name(name='building-name'))
positions = BuildingPrototype.get_available_positions(
self.place_1.x, self.place_1.y)
self.assertTrue(positions)
for place in places_storage.all():
self.assertFalse((place.x, place.y) in positions)
for building in buildings_storage.all():
self.assertFalse((building.x, building.y) in positions)
for x, y in positions:
self.assertTrue(0 <= x < map_settings.WIDTH)
self.assertTrue(0 <= y < map_settings.HEIGHT)
def _point_arrow_height(obj, borders, length_normalizer, width_normalizer,
power_percent):
distances = []
for other_place in places_storage.all():
if obj.id != other_place.id:
distances.append((math.hypot(obj.x - other_place.x,
obj.y - other_place.y), other_place))
distances = sorted(distances, key=lambda x: x[0])
arrows = []
if len(distances) > 0:
distance, other_place = distances[0] # pylint: disable=W0612
arrow = power_points.ArrowAreaPoint.Arrow(angle=math.atan2(
other_place.y - obj.y, other_place.x - obj.x),
length=obj.r,
width=(obj.r / 3) + 1)
arrows.extend([arrow, arrow.rounded_arrow])
if len(distances) > 1:
distance, other_place = distances[1]
arrow = power_points.ArrowAreaPoint.Arrow(angle=math.atan2(
other_place.y - obj.y, other_place.x - obj.x),
length=obj.r,
width=(obj.r / 3) + 1)
arrows.extend([arrow, arrow.rounded_arrow])
return power_points.ArrowAreaPoint(layer_type=layers.LAYER_TYPE.HEIGHT,
name='height_arrow_' + obj.uid,
x=obj.x,
y=obj.y,
power=get_height_power_function(
borders, power_percent),
default_power=(0.0, 0.0),
length_normalizer=length_normalizer,
width_normalizer=width_normalizer,
arrows=arrows)
def get_available_positions(cls, center_x, center_y, building_position_radius=places_settings.BUILDING_POSITION_RADIUS): # pylint: disable=R0914
from the_tale.game.map.places.storage import places_storage, buildings_storage
from the_tale.game.map.roads.storage import roads_storage
from the_tale.game.map.roads.relations import PATH_DIRECTION
positions = set()
for i in xrange(0, building_position_radius+1):
for j in xrange(0, building_position_radius+1):
positions.add((center_x+i, center_y+j))
positions.add((center_x-i, center_y+j))
positions.add((center_x+i, center_y-j))
positions.add((center_x-i, center_y-j))
positions = set(pos for pos in positions
if 0 <= pos[0] < map_settings.WIDTH and 0 <= pos[1] < map_settings.HEIGHT)
removed_positions = set()
for place in places_storage.all():
removed_positions.add((place.x, place.y))
for building in buildings_storage.all():
removed_positions.add((building.x, building.y))
for road in roads_storage.all_exists_roads():
x, y = road.point_1.x, road.point_1.y
for direction in road.path:
if direction == PATH_DIRECTION.LEFT.value: x -= 1
elif direction == PATH_DIRECTION.RIGHT.value: x += 1
elif direction == PATH_DIRECTION.UP.value: y -= 1
elif direction == PATH_DIRECTION.DOWN.value: y += 1
removed_positions.add((x, y))
result = positions - removed_positions
return result if result else cls.get_available_positions(center_x, center_y, building_position_radius=building_position_radius+1)
def form_choices(cls, only_weak=False, choosen_person=None, predicate=lambda place, person: True):
choices = []
for place in places_storage.all():
persons_choices = filter(lambda person: predicate(place, person), place.persons) # pylint: disable=W0110
accepted_persons = persons_choices[place.max_persons_number/2:] if only_weak else persons_choices
if choosen_person is not None and choosen_person.place.id == place.id:
if choosen_person.id not in [p.id for p in accepted_persons]:
accepted_persons.append(choosen_person)
place_power = place.total_persons_power
persons = tuple( (person.id, u'%s [%s %.2f%%]' % (person.name,
person.type.text,
person.power / place_power * 100 if place_power > 0.001 else 0))
for person in accepted_persons )
persons = sorted(persons, key=lambda choice: choice[1])
choices.append( ( place.name, persons ) )
return sorted(choices, key=lambda choice: choice[0])
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.shift_all(dx, dy)
buildings_storage.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 xrange(0, generator.h):
row = []
terrain.append(row)
for x in xrange(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.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()) }
region_js_file = map_settings.GEN_REGION_OUTPUT % map_info_storage.version
output_dir_name = os.path.dirname(region_js_file)
if not os.path.exists(output_dir_name):
os.makedirs(output_dir_name, 0755)
with open(region_js_file, 'w') as region_json_file:
region_json_file.write(s11n.to_json(data).encode('utf-8'))
if project_settings.DEBUG:
deworld.draw_world(index, generator, catalog=map_settings.GEN_WORLD_PROGRESSION)
def test_new_place_renaming(self):
texts = [('>'+place.name+'<', 1) for place in places_storage.all()]
self.check_html_ok(self.request_html(reverse('game:bills:new') + ('?bill_type=%s' % PlaceRenaming.type.value)), texts=texts)
def test_edit_place_renaming(self):
texts = [('>'+place.name+'<', 1) for place in places_storage.all()]
self.check_html_ok(self.request_html(reverse('game:bills:edit', args=[self.bill.id])), texts=texts)
def create_map(self): # pylint: disable=R0914, R0915
Place.objects.all().delete()
Road.objects.all().delete()
p1x1 = self.create_place(1, 1, size=1)
p14x1 = self.create_place(14, 1, size=1)
p27x1 = self.create_place(27, 1, size=6)
p5x3 = self.create_place(5, 3, size=5)
p1x9 = self.create_place(1, 9, size=6)
p5x12 = self.create_place(5, 12, size=1)
p3x17 = self.create_place(3, 17, size=10)
p10x18 = self.create_place(10, 18, size=3)
p11x11 = self.create_place(11, 11, size=4)
p11x6 = self.create_place(11, 6, size=4)
p19x5 = self.create_place(19, 5, size=3)
p20x8 = self.create_place(20, 8, size=9)
p24x8 = self.create_place(24, 8, size=10)
p17x12 = self.create_place(17, 12, size=2)
p19x17 = self.create_place(19, 17, size=8)
p24x13 = self.create_place(24, 13, size=1)
p27x13 = self.create_place(27, 13, size=1)
p28x19 = self.create_place(28, 19, size=3)
self.create_road(p1x1, p5x3)
self.create_road(p5x3, p1x9)
self.create_road(p5x3, p11x6)
self.create_road(p1x9, p5x12)
self.create_road(p5x12, p3x17)
self.create_road(p5x12, p11x11)
self.create_road(p3x17, p10x18)
self.create_road(p11x11, p10x18)
self.create_road(p11x11, p11x6)
self.create_road(p11x11, p19x17)
self.create_road(p11x11, p17x12)
self.create_road(p11x11, p20x8)
self.create_road(p11x6, p14x1)
self.create_road(p14x1, p27x1)
self.create_road(p27x1, p24x8)
self.create_road(p24x8, p20x8)
self.create_road(p24x8, p24x13)
self.create_road(p24x8, p27x13)
self.create_road(p20x8, p19x5)
self.create_road(p20x8, p17x12)
self.create_road(p19x17, p24x13)
self.create_road(p28x19, p24x13)
self.create_road(p28x19, p27x13)
places_storage.update_version()
roads_storage.update_version()
for place in places_storage.all():
place.sync_persons(force_add=True)
persons_storage.update_version()
terrain = []
for y in xrange(0, map_settings.HEIGHT): # pylint: disable=W0612
row = []
terrain.append(row)
for x in xrange(0, map_settings.WIDTH): # pylint: disable=W0612
row.append(TERRAIN.PLANE_GREENWOOD)
map_info_storage.set_item(
MapInfoPrototype.create(turn_number=0,
width=map_settings.WIDTH,
height=map_settings.HEIGHT,
terrain=terrain,
world=WorldInfoPrototype.create(
w=map_settings.WIDTH,
h=map_settings.HEIGHT)))
map_info_storage.update_version()
def test_correct_objects_power__places(self):
self.check_correct_objects_power(places_storage.all())
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.shift_all(dx, dy)
buildings_storage.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 xrange(0, generator.h):
row = []
terrain.append(row)
for x in xrange(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.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())
}
region_js_file = map_settings.GEN_REGION_OUTPUT % map_info_storage.version
output_dir_name = os.path.dirname(region_js_file)
if not os.path.exists(output_dir_name):
os.makedirs(output_dir_name, 0755)
with open(region_js_file, 'w') as region_json_file:
region_json_file.write(s11n.to_json(data).encode('utf-8'))
if project_settings.DEBUG:
deworld.draw_world(index,
generator,
catalog=map_settings.GEN_WORLD_PROGRESSION)
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 create_map(self): # pylint: disable=R0914, R0915
Place.objects.all().delete()
Road.objects.all().delete()
p1x1 = self.create_place(1, 1, size=1)
p14x1 = self.create_place(14, 1, size=1)
p27x1 = self.create_place(27, 1, size=6)
p5x3 = self.create_place(5, 3, size=5)
p1x9 = self.create_place(1, 9, size=6)
p5x12 = self.create_place(5, 12, size=1)
p3x17 = self.create_place(3, 17, size=10)
p10x18 = self.create_place(10, 18, size=3)
p11x11 = self.create_place(11, 11, size=4)
p11x6 = self.create_place(11, 6, size=4)
p19x5 = self.create_place(19, 5, size=3)
p20x8 = self.create_place(20, 8, size=9)
p24x8 = self.create_place(24, 8, size=10)
p17x12 = self.create_place(17, 12, size=2)
p19x17 = self.create_place(19, 17, size=8)
p24x13 = self.create_place(24, 13, size=1)
p27x13 = self.create_place(27, 13, size=1)
p28x19 = self.create_place(28, 19, size=3)
self.create_road(p1x1, p5x3)
self.create_road(p5x3, p1x9)
self.create_road(p5x3, p11x6)
self.create_road(p1x9, p5x12)
self.create_road(p5x12, p3x17)
self.create_road(p5x12, p11x11)
self.create_road(p3x17, p10x18)
self.create_road(p11x11, p10x18)
self.create_road(p11x11, p11x6)
self.create_road(p11x11, p19x17)
self.create_road(p11x11, p17x12)
self.create_road(p11x11, p20x8)
self.create_road(p11x6, p14x1)
self.create_road(p14x1, p27x1)
self.create_road(p27x1, p24x8)
self.create_road(p24x8, p20x8)
self.create_road(p24x8, p24x13)
self.create_road(p24x8, p27x13)
self.create_road(p20x8, p19x5)
self.create_road(p20x8, p17x12)
self.create_road(p19x17, p24x13)
self.create_road(p28x19, p24x13)
self.create_road(p28x19, p27x13)
places_storage.update_version()
roads_storage.update_version()
for place in places_storage.all():
place.sync_persons(force_add=True)
persons_storage.update_version()
terrain = []
for y in xrange(0, map_settings.HEIGHT): # pylint: disable=W0612
row = []
terrain.append(row)
for x in xrange(0, map_settings.WIDTH): # pylint: disable=W0612
row.append(TERRAIN.PLANE_GREENWOOD)
map_info_storage.set_item(MapInfoPrototype.create(turn_number=0,
width=map_settings.WIDTH,
height=map_settings.HEIGHT,
terrain=terrain,
world=WorldInfoPrototype.create(w=map_settings.WIDTH, h=map_settings.HEIGHT)))
map_info_storage.update_version()
def get_dominant_place(self, x, y):
for place in places_storage.all():
if (x, y) in place.nearest_cells:
return place
return None
def create_test_map():
linguistics_logic.sync_static_restrictions()
map_logic.create_test_my_info()
p1 = PlacePrototype.create(
x=1, y=1, size=1, utg_name=names.generator.get_test_name(name='1x1'))
p2 = PlacePrototype.create(
x=3, y=3, size=3, utg_name=names.generator.get_test_name(name='10x10'))
p3 = PlacePrototype.create(
x=1, y=3, size=3, utg_name=names.generator.get_test_name(name='1x10'))
for place in places_storage.all():
place.sync_persons(force_add=True)
RoadPrototype.create(point_1=p1, point_2=p2).update()
RoadPrototype.create(point_1=p2, point_2=p3).update()
update_waymarks()
update_nearest_cells()
mob_1 = MobRecordPrototype.create_random('mob_1')
mob_2 = MobRecordPrototype.create_random('mob_2')
mob_3 = MobRecordPrototype.create_random('mob_3')
ArtifactRecordPrototype.create_random('loot_1', mob=mob_1)
ArtifactRecordPrototype.create_random('loot_2', mob=mob_2)
ArtifactRecordPrototype.create_random('loot_3', mob=mob_3)
ArtifactRecordPrototype.create_random('helmet_1',
type_=ARTIFACT_TYPE.HELMET,
mob=mob_1)
ArtifactRecordPrototype.create_random('plate_1',
type_=ARTIFACT_TYPE.PLATE,
mob=mob_2)
ArtifactRecordPrototype.create_random('boots_1',
type_=ARTIFACT_TYPE.BOOTS,
mob=mob_3)
ArtifactRecordPrototype.create_random(DEFAULT_HERO_EQUIPMENT.PANTS,
type_=ARTIFACT_TYPE.PANTS)
ArtifactRecordPrototype.create_random(DEFAULT_HERO_EQUIPMENT.BOOTS,
type_=ARTIFACT_TYPE.BOOTS)
ArtifactRecordPrototype.create_random(DEFAULT_HERO_EQUIPMENT.PLATE,
type_=ARTIFACT_TYPE.PLATE)
ArtifactRecordPrototype.create_random(DEFAULT_HERO_EQUIPMENT.GLOVES,
type_=ARTIFACT_TYPE.GLOVES)
ArtifactRecordPrototype.create_random(DEFAULT_HERO_EQUIPMENT.WEAPON,
type_=ARTIFACT_TYPE.MAIN_HAND)
companions_logic.create_random_companion_record(
'companion_1',
dedication=companions_relations.DEDICATION.HEROIC,
state=companions_relations.STATE.ENABLED)
companions_logic.create_random_companion_record(
'companion_2',
dedication=companions_relations.DEDICATION.BOLD,
state=companions_relations.STATE.ENABLED)
companions_logic.create_random_companion_record(
'companion_3',
dedication=companions_relations.DEDICATION.BOLD,
state=companions_relations.STATE.DISABLED)
return p1, p2, p3
def all_places():
return sorted(places_storage.all(), key=lambda p: p.name)
def choose_preferences_dialog(self, type): # pylint: disable=W0622
mobs = None
places = None
friends = None
enemies = None
equipment_slots = None
favorite_items = None
all_places = places_storage.all()
all_places.sort(key=lambda x: x.name)
if type.is_ENERGY_REGENERATION_TYPE:
pass
if type.is_MOB:
all_mobs = mobs_storage.get_available_mobs_list(level=self.hero.level)
all_mobs = sorted(all_mobs, key=lambda x: x.name)
mobs = split_list(all_mobs)
elif type.is_PLACE:
places = split_list(all_places)
elif type.is_FRIEND:
friends = sorted([person for person in persons_storage.filter(state=PERSON_STATE.IN_GAME)],
key=lambda person: person.name)
elif type.is_ENEMY:
enemies = sorted([person for person in persons_storage.filter(state=PERSON_STATE.IN_GAME)],
key=lambda person: person.name)
elif type.is_EQUIPMENT_SLOT:
equipment_slots = split_list(list(relations.EQUIPMENT_SLOT.records))
elif type.is_RISK_LEVEL:
pass
elif type.is_ARCHETYPE:
pass
elif type.is_COMPANION_DEDICATION:
pass
elif type.is_COMPANION_EMPATHY:
pass
elif type.is_FAVORITE_ITEM:
favorite_items = {slot: self.hero.equipment.get(slot)
for slot in relations.EQUIPMENT_SLOT.records
if self.hero.equipment.get(slot) is not None}
return self.template('heroes/choose_preferences.html',
{'type': type,
'mobs': mobs,
'places': places,
'all_places': places_storage.get_choices(),
'places_powers': {place.id: place.total_persons_power for place in all_places},
'friends': friends,
'enemies': enemies,
'equipment_slots': equipment_slots,
'favorite_items': favorite_items,
'PREFERENCES_CHANGE_DELAY': datetime.timedelta(seconds=c.PREFERENCES_CHANGE_DELAY),
'EQUIPMENT_SLOT': relations.EQUIPMENT_SLOT,
'RISK_LEVEL': relations.RISK_LEVEL,
'COMPANION_DEDICATION': relations.COMPANION_DEDICATION,
'COMPANION_EMPATHY': relations.COMPANION_EMPATHY,
'ARCHETYPE': game_relations.ARCHETYPE} )
def sync_data(self, sheduled=True):
self.logger.info('sync data')
all_persons = persons_storage.persons_storage.filter(
state=PERSON_STATE.IN_GAME)
self.sync_persons_powers(persons=[
person for person in all_persons if person.place.is_frontier
])
self.sync_persons_powers(persons=[
person for person in all_persons if not person.place.is_frontier
])
for person in all_persons:
person.update_friends_number()
person.update_enemies_number()
self.persons_power = {}
self.sync_places_powers(places=[
place for place in places_storage.all() if place.is_frontier
])
self.sync_places_powers(places=[
place for place in places_storage.all() if not place.is_frontier
])
self.places_power = {}
# update size
if sheduled:
self.sync_sizes(
[place for place in places_storage.all() if place.is_frontier],
hours=c.MAP_SYNC_TIME_HOURS,
max_size=places_settings.MAX_FRONTIER_SIZE)
self.sync_sizes([
place
for place in places_storage.all() if not place.is_frontier
],
hours=c.MAP_SYNC_TIME_HOURS,
max_size=places_settings.MAX_SIZE)
for place in places_storage.all():
place.sync_stability()
place.sync_modifier()
place.sync_habits()
place.sync_parameters(
) # must be last operation to display and use real data
place.update_heroes_number()
place.update_heroes_habits()
place.mark_as_updated()
places_storage.save_all()
persons_storage.persons_storage.remove_out_game_persons()
persons_storage.persons_storage.save_all()
persons_logic.sync_social_connections()
if sheduled:
for building in buildings_storage.all():
building.amortize(c.MAP_SYNC_TIME)
buildings_storage.save_all()
self.logger.info('sync data completed')
def all_places():
return sorted(places_storage.all(), key=lambda p: p.name)
