def skill_xref_report(data, teaches_chain, outdir): skill_list = sorted(list(teaches_chain)) sort_skill_xref_list = [] for unit in skill_list: city_list = teaches_chain[unit] if len(city_list) > 0 and unit is not None: skill_rec = data[unit] for city in city_list: city_rec = data[city] where_rec = data[city_rec['LI']['wh'][0]] loc_dict = { 'id': city, 'oid': to_oid(city), 'name': get_name(city_rec) } sort_skill_xref_dict = { 'id': unit, 'oid': to_oid(unit), 'name': get_name(skill_rec), 'loc_dict': loc_dict, 'where_dict': get_where_info(city_rec, data), 'region_dict': get_region(city, data) } sort_skill_xref_list.append(sort_skill_xref_dict) outf = open( pathlib.Path(outdir).joinpath('master_skill_xref_report.html'), 'w') template = olymap.env.get_template('master_skill_xref_report.html') loc = sort_skill_xref_list outf.write(template.render(loc=loc))
def get_project_cast(v, data): projected_cast = v.get('IM', {}).get('pc', [None]) projected_cast_id = projected_cast[0] if projected_cast_id is not None: try: projected_cast_rec = data[projected_cast_id] try: region_id = u.region(projected_cast_id, data) region_rec = data[region_id] region_oid = to_oid(region_id) region_name = get_name(region_rec) except KeyError: region_id = None region_oid = None region_name = None projected_dict = {'id': projected_cast_id, 'oid': to_oid(projected_cast_id), 'name': get_name(projected_cast_rec), 'kind': u.return_kind(projected_cast_rec), 'region_id': region_id, 'region_oid': region_oid, 'region_name': region_name} except KeyError: projected_dict = {'id': None, 'oid': to_oid(projected_cast_id)} return projected_dict return None
def get_skills_known(v, data): skills_list = v.get('CH', {}).get('sl', [None]) if skills_list[0] is None: return None skills_dict = defaultdict(list) if len(skills_list) > 0: for skill in range(0, len(skills_list), 5): skills_dict[skills_list[skill]].append(skills_list[skill + 1]) skills_dict[skills_list[skill]].append(skills_list[skill + 2]) skills_dict[skills_list[skill]].append(skills_list[skill + 3]) skills_dict[skills_list[skill]].append(skills_list[skill + 4]) sort_list = [] for skill in skills_dict: skill_id = skill skills_rec = skills_dict[skill] know = skills_rec[0] sort_list.append([int(know) * -1, skill_id]) sort_list.sort() printknown = False printunknown = False skill_list = [] for skill in sort_list: skill_id = skill[1] skills_rec = skills_dict[skill_id] know = skills_rec[0] days_studied = skills_rec[1] if know == '2': if not printknown: printknown = True skillz = data[skill_id] if 'SK' in skillz and 'rs' in skillz['SK']: req_skill = skillz['SK']['rs'][0] else: req_skill = '0' skill_dict = { 'oid': to_oid(skill_id), 'name': get_name(skillz), 'req_skill': req_skill, 'known': 'Yes', 'days_studied': None, 'to_lear': None } skill_list.append(skill_dict) if know == '1': if not printunknown: printunknown = True skillz = data[skill_id] skill_dict = { 'oid': to_oid(skill_id), 'name': get_name(skillz), 'req_skill': None, 'known': 'No', 'days_studied': days_studied, 'to_learn': skillz['SK']['tl'][0] } skill_list.append(skill_dict) return skill_list
def create_loc_to_dict_entry(data, direction, to_loc_rec, from_loc_rec, region_rec): to_dict = {'id': u.return_unitid(to_loc_rec), 'oid': to_oid(u.return_unitid(to_loc_rec)), 'name': get_name(to_loc_rec), 'subkind': get_subkind(to_loc_rec, data), 'is_port': u.is_port_city(to_loc_rec, data), 'prov_port': u.province_has_port_city(to_loc_rec, data), 'region_oid': to_oid(u.return_unitid(region_rec)), 'region_name': get_name(region_rec), 'direction': direction, 'barrier': get_barrier(u.return_unitid(to_loc_rec), to_loc_rec, data), 'distance': u.calc_exit_distance(from_loc_rec, to_loc_rec), 'impassable': is_impassable(from_loc_rec, to_loc_rec, direction, data)} return to_dict
def get_aura(box, data): if u.is_magician(box): rank = u.xlate_magetype(box, data) current_aura = get_current_aura(box) max_aura = u.get_max_aura(box) auraculum_aura = 0 if u.get_auraculum_id(box) is not None: auraculum_id = u.get_auraculum_id(box) auraculum_box = data[auraculum_id] auraculum_aura = u.get_auraculum_aura(auraculum_box) auraculum_dict = { 'id': auraculum_id, 'oid': to_oid(auraculum_id), 'name': get_name(auraculum_box), 'aura': auraculum_aura } else: auraculum_dict = None aura_dict = { 'rank': rank, 'current_aura': current_aura, 'max_aura': max_aura, 'total_aura': max_aura + auraculum_aura, 'auraculum_dict': auraculum_dict } return aura_dict return None
def build_complete_item_dict(k, v, data, trade_chain): item_dict = {'oid' : get_oid(k), 'name' : get_name(v), 'subkind' : get_subkind(v, data), 'plural' : get_plural(v), 'animal' : get_animal(v), 'attack' : get_item_attack(v), 'aura' : get_auraculum_aura(v), 'dead_body_dict': get_dead_body(v, data), 'defense' : get_item_defense(v), 'fly_capacity' : get_fly_capacity(v), 'land_capacity' : get_land_capacity(v), 'lore' : get_lore(v), 'man_item': get_man_item(v), 'may_study_dict': get_may_study(v, data), 'missile' : get_item_missile(v), 'project_cast' : get_project_cast(v, data), 'prominent' : get_prominent(v), 'ride_capacity' : get_ride_capacity(v), 'use_key' : get_use_key(v), 'weight' : get_item_weight(v), 'who_has_dict': get_who_has(v, data), 'trade_good' : get_trade_good(k, v, data, trade_chain), 'magic_info': get_magic_item(data, k, v)} return item_dict
def build_complete_ship_dict(k, v, data, instance, pledge_chain, prisoner_chain): ship_dict = { 'oid': get_oid(k), 'name': get_name(v), 'subkind': get_subkind(v, data), 'kind': 'kind', 'complete': get_complete(v), 'load': get_load(k, v, data), 'defense': get_defense(v)[0], 'damage': get_ship_damage(v), 'owner': build_owner_dict(v, data), 'storm': build_storm_dict(v, data), 'seen_here': build_seenhere_dict(k, v, data, instance, pledge_chain, prisoner_chain), 'non_prominent_items': build_non_prominent_items_dict(k, v, data), 'loc': build_loc_dict(v, data) } return ship_dict
def get_region(k, data): region_id = u.region(k, data) region_rec = data[region_id] region_dict = {'id': region_id, 'oid': to_oid(region_id), 'name': get_name(region_rec)} return region_dict
def gold_report(data, outdir): character_list = [] for unit in data: unit_box = data[unit] if u.is_char(unit_box): character_list.append(unit) # character_list.sort() # for unit in character_list: sort_gold_list = [] for unit in sorted(character_list, key=lambda x: int(x)): character_rec = data[unit] items_list = get_items_list(character_rec, data, False, '1') if items_list != []: if int(items_list[0]['qty']) > 10000: gold_dict = { 'id': unit, 'oid': to_oid(unit), 'name': get_name(character_rec), 'loc': get_loc(character_rec, data), 'qty': int(items_list[0]['qty']) } sort_gold_list.append(gold_dict) outf = open(pathlib.Path(outdir).joinpath('master_gold_report.html'), 'w') template = olymap.env.get_template('master_gold_report.html') char = sort_gold_list outf.write(template.render(char=char))
def get_shroud(k, v, data): shroud = v.get('LO', {}).get('sh', [None]) if shroud[0] is not None and shroud[0] != '0': shroud_dict = {'oid': to_oid(k), 'name': get_name(v)} return shroud_dict else: return None
def get_barrier(k, v, data): barrier = v.get('LO', {}).get('ba', [None]) if barrier[0] is not None and barrier[0] != '0': barrier_dict = {'oid': to_oid(k), 'name': get_name(v)} return barrier_dict else: return None
def build_basic_storm_dict(k, v, data): storm_dict = { 'oid': get_oid(k), 'name': get_name(v), 'subkind': get_subkind(v, data), 'kind': 'storm', 'strength': get_strength(v) } return storm_dict
def build_loc_dict(v, data): loc_id = v['LI']['wh'][0] loc_rec = data[loc_id] loc_dict = { 'oid': get_oid(loc_id), 'name': get_name(loc_rec), 'subkind': get_subkind(loc_rec, data) } return loc_dict
def get_dead_body(v, data): dead_body_id = v.get('PL', {}).get('un', [None])[0] if dead_body_id is not None: dead_body_box = data[dead_body_id] dead_body_dict = {'id': dead_body_id, 'oid': to_oid(dead_body_id), 'name': get_name(dead_body_box)} return dead_body_dict return None
def trade_report(data, trade_chain, outdir): trade_list = sorted(list(trade_chain)) sort_trade_list = [] for unit in trade_list: city_list = trade_chain[unit] if len(city_list) > 0 and unit is not None: item_rec = data[unit] sell_list = [] buy_list = [] for city in city_list: city_id = city[0] city_rec = data[city_id] region_id = u.region(city_id, data) region_rec = data[region_id] if city[1] == '1': buy_dict = { 'id': city_id, 'oid': to_oid(city_id), 'name': get_name(city_rec), 'region_oid': to_oid(region_id), 'region_name': get_name(region_rec) } buy_list.append(buy_dict) else: sell_dict = { 'id': city_id, 'oid': to_oid(city_id), 'name': get_name(city_rec), 'region_oid': to_oid(region_id), 'region_name': get_name(region_rec) } sell_list.append(sell_dict) trade_entry = { 'id': unit, 'oid': to_oid(unit), 'name': get_name(item_rec), 'buy_list': buy_list, 'sell_list': sell_list } sort_trade_list.append((trade_entry)) outf = open(pathlib.Path(outdir).joinpath('master_trade_report.html'), 'w') template = olymap.env.get_template('master_trade_report.html') loc = sort_trade_list outf.write(template.render(loc=loc))
def build_basic_skill_dict(k, v, data, teaches_chain, child_skills_chain, skills_known_chain): skills_dict = { 'id': k, 'oid': to_oid(k), 'name': get_name(v), 'required_skill': get_required_skill(v, data), 'learn_time': get_learn_time(v) } return skills_dict
def build_basic_char_dict(k, v, data, prominent_only=False): if not u.is_garrison(v): char_dict = { 'id': k, 'oid': get_oid(k), 'name': get_name(v), 'subkind': get_subkind(v, data), 'kind': 'char', 'rank': get_rank(v), 'faction': get_faction(v, data), 'health_dict': get_health(v), 'nbr_men': get_nbr_men(v, data), 'absorb_blast': u.is_absorb_aura_blast(v), 'prisoner': u.is_prisoner(v), 'stacked_over_list': get_stacked_over(v, data), 'priest': u.is_priest(v), 'magetype': u.xlate_magetype(v, data), 'on_guard': u.is_on_guard(v), 'concealed': u.is_concealed(v), 'wearable': get_wearable_wielding(v, data), 'loyalty': get_loyalty(v), 'skills_known_list': get_skills_known(v, data), 'inventory_dict': get_inventory(v, data, prominent_only), 'aura_dict': get_aura(v, data), 'priest_dict': get_priest_skills(v, data) } return char_dict else: char_dict = { 'id': k, 'oid': get_oid(k), 'name': get_name(v), 'subkind': get_subkind(v, data), 'kind': 'char', 'faction': get_faction(v, data), 'health_dict': get_health(v), 'nbr_men': get_nbr_men(v, data), 'on_guard': u.is_on_guard(v), 'loyalty': get_loyalty(v), 'inventory_dict': get_inventory(v, data, prominent_only) } return char_dict
def build_complete_storm_dict(k, v, data, storm_chain): storm_dict = { 'oid': get_oid(k), 'name': get_name(v), 'subkind': get_subkind(v, data), 'kind': 'storm', 'strength': get_strength(v), 'loc': build_loc_dict(v, data), 'ship': build_ship_dict(k, data, storm_chain) } return storm_dict
def get_skills_taught(v, data): skills_taught_list = [] if 'SL' in v and 'te' in v['SL']: skills_list = v['SL']['te'] if len(skills_list) > 0: for skill in skills_list: skill_rec = data[skill] skills_dict = {'oid': to_oid(skill), 'name': get_name(skill_rec)} skills_taught_list.append(skills_dict) return skills_taught_list
def build_ship_dict(k, data, storm_chain): ship_id = get_bound_ship(k, storm_chain) if ship_id is not None: ship_rec = data[ship_id] ship_dict = { 'id': ship_id, 'oid': get_oid(ship_id), 'name': get_name(ship_rec) } else: ship_dict = None return ship_dict
def build_basic_loc_dict(k, v, data, garrisons_chain=None): loc_dict = {'oid': to_oid(k), 'name': get_name(v), 'subkind': get_subkind(v, data), 'kind': u.return_kind(v), 'where': get_where_info(v, data), 'hidden': u.is_hidden(v), 'structure': get_structure_info(v), 'seen_here': get_here_list(k, v, data), 'region': get_region(k, data), 'garrisons': get_garrisons(k, v, data, garrisons_chain),} return loc_dict
def get_required_study(box, data): skill_id = box.get('SK', {}).get('rs', [None])[0] if skill_id is not None: try: skill_box = data[skill_id] except: return None skill_dict = {'id': skill_id, 'oid': to_oid(skill_id), 'name': get_name(skill_box)} return skill_dict return None
def build_owner_dict(v, data): if get_owner(v) is not None: owner_id = get_owner(v) owner_rec = data[owner_id] owner_dict = { 'id': owner_id, 'oid': get_oid(owner_id), 'name': get_name(owner_rec) } else: owner_dict = None return owner_dict
def get_unit_list(v, data): units_list = [] if 'PL' in v and 'un' in v['PL']: unit_list = v['PL']['un'] unit_list.sort() for unit in unit_list: unit_rec = data[unit] unit_dict={'id': unit, 'oid': to_oid(unit), 'name': get_name(unit_rec)} units_list.append(unit_dict) return units_list
def get_required_skill(v, data): required_skill = v.get('SK', {}).get('rs', [None]) if required_skill[0] is not None: skill_id = required_skill[0] skill_rec = data[skill_id] required_skill_dict = { 'id': skill_id, 'oid': to_oid(skill_id), 'name': get_name(skill_rec) } return required_skill_dict return None
def get_routes_out(k, v, data): routes_out_list = [] if not u.is_city(v): dest_dict = get_destinations(k, v, data) else: dest_list = [] host_prov_id = v['LI']['wh'][0] host_prov_rec = data[host_prov_id] # If city is in a mountain, can't move from city to ocean if not u.is_mountain(host_prov_rec): dest_loc_list = host_prov_rec['LO']['pd'] i = int(0) for pd in dest_loc_list: if pd != '0': pd_loc = data[pd] if u.is_ocean(pd_loc): pd_name = pd_loc['na'][0] pd_loc_id = u.return_unitid(pd_loc) pd_rec = data[pd_loc_id] direction = pd_directions[i] region_id = u.region(pd_loc_id, data) region_rec = data[region_id] to_dict = create_loc_to_dict_entry(data, direction, pd_rec, v, region_rec) dest_list.append(to_dict) i = i + 1 region_id = u.region(host_prov_id, data) region_rec = data[region_id] direction = 'Out' to_dict = create_loc_to_dict_entry(data, direction, host_prov_rec, v, region_rec) dest_list.append(to_dict) region_id = u.region(k, data) region_rec = data[region_id] dest_dict = {'id': k, 'oid': to_oid(k), 'name': get_name(v), 'subkind': get_subkind(v, data), 'region_oid': to_oid(region_id), 'region_name': get_name(region_rec), 'dest': dest_list} return dest_dict
def faeryhill_report(data, outdir): faeryhill_list = [] for unit in data: unit_box = data[unit] if u.is_faeryhill(unit_box): faeryhill_list.append(unit) # faeryhill_list.sort() # for unit in faeryhill_list: sort_faeryhill_list = [] for unit in sorted(faeryhill_list, key=lambda x: int(x)): faeryhill_rec = data[unit] # SL/lt if 'SL' in faeryhill_rec and 'lt' in faeryhill_rec['SL']: target_id = faeryhill_rec['SL']['lt'][0] target_rec = data[target_id] target_dict = { 'id': target_id, 'oid': to_oid(target_id), 'name': get_name(target_rec) } target_region_dict = get_region(target_id, data) else: target_rec = None target_dict = None target_region_dict = None sort_faeryhill_dict = { 'id:': unit, 'oid': to_oid(unit), 'name': get_name(faeryhill_rec), 'where_dict': get_where_info(faeryhill_rec, data), 'region_dict': get_region(unit, data), 'target_dict': target_dict, 'target_region_dict': target_region_dict } sort_faeryhill_list.append((sort_faeryhill_dict)) outf = open( pathlib.Path(outdir).joinpath('master_faeryhill_report.html'), 'w') template = olymap.env.get_template('master_faeryhill_report.html') loc = sort_faeryhill_list outf.write(template.render(loc=loc))
def build_complete_skill_dict(k, v, data, teaches_chain, child_skills_chain, skills_known_chain): skills_dict = { 'id': k, 'oid': to_oid(k), 'name': get_name(v), 'required_skill': get_required_skill(v, data), 'learn_time': get_learn_time(v), 'known_by': get_known_by(k, v, data, skills_known_chain), 'child_skills': get_child_skills(k, v, data, child_skills_chain), 'taught_in': get_taught_in(k, v, data, teaches_chain) } return skills_dict
def get_child_skills(k, v, data, child_skills_chain): child_skills_list = [] child_list = child_skills_chain[k] if len(child_list) > 0: for skill in child_list: skill_rec = data[skill] skill_dict = { 'id': skill, 'oid': to_oid(skill), 'name': get_name(skill_rec) } child_skills_list.append(skill_dict) return child_skills_list
def get_known_by(k, v, data, skills_known_chain): known_by_list = [] char_list = skills_known_chain[k] if len(char_list) > 0: for char in char_list: char_rec = data[char] char_dict = { 'id': char, 'oid': to_oid(char), 'name': get_name(char_rec) } known_by_list.append(char_dict) return known_by_list