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 persons(self):
from the_tale.game.persons.storage import persons_storage
from the_tale.game.persons.relations import PERSON_STATE
return sorted(persons_storage.filter(place_id=self.id,
state=PERSON_STATE.IN_GAME),
key=lambda p: -p.power)
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 persons(self):
from the_tale.game.persons.storage import persons_storage
from the_tale.game.persons.relations import PERSON_STATE
return sorted(persons_storage.filter(place_id=self.id, state=PERSON_STATE.IN_GAME), key=lambda p: -p.power)
