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
