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 generate_topnav(currentpoint, outf, prefix, upperleftnav, upperrightnav,
xx, yy, map_matrix):
upper_left_nav_dict = {}
if upperleftnav:
printpoint = map_matrix[yy - 10][xx - 10]
upper_left_nav_dict = {
'oid': to_oid(printpoint),
'width': 20,
'height': 20
}
printpoint = map_matrix[yy - 10][xx]
upper_nav_dict = {'oid': to_oid(printpoint), 'width': 840, 'height': 20}
upper_right_nav_dict = {}
if upperrightnav:
printpoint = map_matrix[yy - 10][xx + 10]
upper_right_nav_dict = {
'oid': to_oid(printpoint),
'width': 20,
'height': 20
}
top_nav_dict = {
'upper_left_nav_dict': upper_left_nav_dict,
'upper_nav_dict': upper_nav_dict,
'upper_right_nav_dict': upper_right_nav_dict
}
return top_nav_dict
def generate_botnav(currentpoint, lowerleftnav, lowerrightnav, outf, prefix):
lower_left_nav_dict = {}
if lowerleftnav:
printpoint = currentpoint + 990
lower_left_nav_dict = {
'oid': to_oid(printpoint),
'width': 20,
'height': 20
}
printpoint = currentpoint + 1000
lower_nav_dict = {'oid': to_oid(printpoint), 'width': 840, 'height': 20}
lower_right_nav_dict = {}
if lowerrightnav:
printpoint = currentpoint + 1010
lower_right_nav_dict = {
'oid': to_oid(printpoint),
'width': 20,
'height': 20
}
bot_nav_dict = {
'lower_left_nav_dict': lower_left_nav_dict,
'lower_nav_dict': lower_nav_dict,
'lower_right_nav_dict': lower_right_nav_dict
}
return bot_nav_dict
def write_loc_routes_out(v, data, outf):
if u.return_type(v) != 'city':
write_province_destinations(v, data, outf)
else:
header_printed = False
host_prov = data[v['LI']['wh'][0]]
# If city is in a mountain, can't move from city to ocean
if u.return_type(host_prov) != 'mountain':
dest_loc_list = host_prov['LO']['pd']
i = int(0)
for pd in dest_loc_list:
try:
pd_loc = data[pd]
if u.return_type(pd_loc) == 'ocean':
if not header_printed:
outf.write('<H4>Routes leaving {}:</H4\n'.format(v['na'][0]))
outf.write('<ul>\n')
pd_name = pd_loc['na'][0]
pd_loc_id = u.return_unitid(pd_loc)
out_distance = u.calc_exit_distance(v, pd_loc)
outf.write('<li>{}, to {} [{}], {}, {} {}</li>\n'
.format(pd_directions[i],
pd_name,
anchor(to_oid(pd_loc_id)),
data[u.region(pd_loc_id, data)]['na'][0],
out_distance,
'day' if out_distance == 1 else 'days'))
except KeyError:
pass
i = i + 1
if not header_printed:
outf.write('<H4>Routes leaving {}:</H4\n'.format(v['na'][0]))
outf.write('<ul>\n')
out_distance = u.calc_exit_distance(v, host_prov)
outf.write('<li>Out, to {} [{}], {} {}</li>\n'
.format(host_prov['na'][0],
anchor(to_oid(u.return_unitid(host_prov))),
out_distance,
'day' if out_distance == 1 else 'days'))
if 'LI' in v:
if 'hl' in v['LI']:
here_list = v['LI']['hl']
for here in here_list:
here_record = data[here]
if u.is_road_or_gate(here_record):
to_record = data[here_record['GA']['tl'][0]]
if u.return_kind(here_record) == 'gate':
name = 'Gate'
else:
name = here_record['na'][0]
if not header_printed:
outf.write('<H4>Routes leaving {}:</H4\n'.format(v['na'][0]))
outf.write('<ul>\n')
write_province_destination(v,
to_record,
name,
data,
outf)
if header_printed:
outf.write('</ul>\n')
def generate_botnav(currentpoint, lowerleftnav, lowerrightnav, outf, prefix,
xx, yy, map_matrix):
lower_left_nav_dict = {}
if lowerleftnav:
printpoint = map_matrix[yy + 10][xx - 10]
lower_left_nav_dict = {
'oid': to_oid(printpoint),
'width': 20,
'height': 20
}
printpoint = map_matrix[yy + 10][xx]
lower_nav_dict = {'oid': to_oid(printpoint), 'width': 840, 'height': 20}
lower_right_nav_dict = {}
if lowerrightnav:
printpoint = map_matrix[yy + 10][xx + 10]
lower_right_nav_dict = {
'oid': to_oid(printpoint),
'width': 20,
'height': 20
}
bot_nav_dict = {
'lower_left_nav_dict': lower_left_nav_dict,
'lower_nav_dict': lower_nav_dict,
'lower_right_nav_dict': lower_right_nav_dict
}
return bot_nav_dict
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 write_loc_page_header(v, k, data, outf):
outf.write('<H3>')
loc_type = u.return_type(v)
outf.write('{} [{}]'.format(v['na'][0], to_oid(k)))
outf.write(', {}'.format(loc_type))
if u.return_type(v) != 'region':
outf.write(', in')
if loc_type == 'city':
outf.write(' province ')
try:
loc2 = data[v['LI']['wh'][0]]
outf.write(' {} [{}]'.format(loc2['na'][0],
anchor(to_oid(u.return_unitid(loc2)))))
except KeyError:
pass
# if 'city' in loc_type:
# outf.write(' [{}]'.format(anchor(to_oid(v['LI']['wh'][0]))))
if 'SL' in v and 'sh' in v['SL']:
outf.write(', safe haven')
if 'LO' in v and 'hi' in v['LO']:
outf.write(', hidden')
if loc_type != 'ocean' and u.loc_depth(u.return_type(v)) == 2 \
and data[u.region(k, data)]['na'][0] != 'faery' and data[u.region(k, data)]['na'][0] != 'hades':
civ_level = 'wilderness'
if 'LO' in v and 'lc' in v['LO']:
if v['LO']['lc'][0] == '0':
civ_level = 'wilderness'
else:
civ_level = 'civ-' + v['LO']['lc'][0]
outf.write(', {}'.format(civ_level))
outf.write('</H3>\n')
def generate_topnav(currentpoint, outf, prefix, upperleftnav, upperrightnav):
upper_left_nav_dict = {}
if upperleftnav:
printpoint = currentpoint - 1010
upper_left_nav_dict = {
'oid': to_oid(printpoint),
'width': 20,
'height': 20
}
printpoint = currentpoint - 1000
upper_nav_dict = {'oid': to_oid(printpoint), 'width': 840, 'height': 20}
upper_right_nav_dict = {}
if upperrightnav:
printpoint = currentpoint - 990
upper_right_nav_dict = {
'oid': to_oid(printpoint),
'width': 20,
'height': 20
}
top_nav_dict = {
'upper_left_nav_dict': upper_left_nav_dict,
'upper_nav_dict': upper_nav_dict,
'upper_right_nav_dict': upper_right_nav_dict
}
return top_nav_dict
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 write_loc_controlled_by(v, data, outf):
if 'LI' in v and 'hl' in v['LI']:
here_list = v['LI']['hl']
if len(here_list) > 0:
for loc in here_list:
try:
charac = data[loc]
except KeyError:
pass
else:
if 'MI' in charac and 'gc' in charac['MI']:
if charac['MI']['gc'][0] != '0':
dest_loc = data[charac['MI']['gc'][0]]
dest_loc2 = data[dest_loc['LI']['wh'][0]]
outf.write('<p>Province controlled by ')
dest_name = dest_loc['na'][0]
dest_id = anchor(to_oid(u.return_unitid(dest_loc)))
dest_type = u.return_type(dest_loc)
outf.write('{} [{}], {}'.format(
dest_name, dest_id, dest_type))
dest_type2 = u.return_type(dest_loc2)
if dest_type2 != 'city':
dest_name2 = dest_loc2['na'][0]
dest_id2 = anchor(
to_oid(u.return_unitid(dest_loc2)))
outf.write(', in {} [{}]'.format(
dest_name2, dest_id2))
else:
dest_loc2 = data[dest_loc2['LI']['wh'][0]]
dest_name2 = dest_loc2['na'][0]
dest_id2 = anchor(
to_oid(u.return_unitid(dest_loc2)))
outf.write(', in {} [{}]'.format(
dest_name2, dest_id2))
try:
garrison = data[dest_loc2['LI']['hl'][0]]
except KeyError:
pass
else:
garr_type = u.return_type(garrison)
if garr_type == 'garrison':
# calculate top of pledge chain
if 'LI' in dest_loc and 'hl' in dest_loc[
'LI']:
top_guy = u.top_ruler(
dest_loc['LI']['hl'][0], data)
try:
top_dog = data[top_guy]
except KeyError:
pass
else:
a = top_dog['na'][0]
b = anchor(to_oid(top_guy))
outf.write(
'<br>Ruled by {} [{}]'.format(
a, b))
outf.write('</p>\n')
def write_loc_map_anchor(v, k, data, outf, instance, inst_dict, map_matrices):
dimensions = inst_dict[instance]
region = u.region(k, data)
region_rec = data[region]
province = u.province(k, data)
if province == 0:
return 0
province_rec = data[province]
custom = False
save_rec = []
save_world = ''
try:
save_rec = map_matrices[region_rec['na'][0].lower()]
save_world = region_rec['na'][0].lower()
custom = True
except KeyError:
try:
save_rec = dimensions[region_rec['na'][0].lower()]
save_world = region_rec['na'][0].lower()
except KeyError:
for world in dimensions:
world_rec = dimensions[world]
if world_rec[0] <= int(province) < world_rec[0] + (world_rec[2] * 100):
save_rec = world_rec
save_world = world
break
# if len(save_rec) == 0:
# print('error {} {}'.format(to_oid(k),
# u.return_type(v)))
if len(save_rec) > 0 and not custom:
world_rec = save_rec
world = save_world
x_coord = int(10 * math.floor((int(province) % 100) / 10))
if x_coord >= world_rec[1] - 10:
x_coord = world_rec[1] - 20
y_coord = int(1000 * math.floor(int(province) / 1000))
if y_coord >= world_rec[0] + (world_rec[2] * 100) - 1000:
y_coord = world_rec[0] + (world_rec[2] * 100) - 2000
if y_coord < world_rec[0]:
y_coord = world_rec[0]
final_coord = y_coord + x_coord
if final_coord < world_rec[0]:
final_coord = world_rec[0]
anchor_string = world + '_map_leaf_' + to_oid(final_coord)
outf.write('<p>{}</p>\n'.format(anchor2(anchor_string, 'Return to map')))
if len(save_rec) > 0 and custom:
world_rec = save_rec
world = save_world
for xx in range(0, len(save_rec[0])):
for yy in range(0,len(save_rec)):
if save_rec[yy][xx] == province:
xxx = int(math.floor(xx / 10)) * 10
yyy = int(math.floor(yy / 10)) * 10
final_coord = save_rec[yyy][xxx]
break
anchor_string = world + '_map_leaf_' + to_oid(final_coord)
outf.write('<p>{}</p>\n'.format(anchor2(anchor_string, 'Return to map')))
def print_wearable_wielding(v, data, outf):
attack_max = 0
missile_max = 0
defense_max = 0
attack = ''
missile = ''
defense = ''
if 'il' in v:
item_list = v['il']
if len(item_list) > 0:
for items in range(0, len(item_list), 2):
itemz = data[item_list[items]]
if 'IM' in itemz:
if 'ab' in itemz['IM']:
if int(itemz['IM']['ab'][0]) > attack_max:
attack_max = int(itemz['IM']['ab'][0])
attack = u.return_unitid(itemz)
if 'mb' in itemz['IM']:
if int(itemz['IM']['mb'][0]) > missile_max:
missile_max = int(itemz['IM']['mb'][0])
missile = u.return_unitid(itemz)
if 'db' in itemz['IM']:
if int(itemz['IM']['db'][0]) > defense_max:
defense_max = int(itemz['IM']['db'][0])
defense = u.return_unitid(itemz)
# found something
if attack != '' or missile != '' or defense != '':
if attack == missile:
missile = ''
if attack == defense:
defense = ''
if attack != '' or missile != '':
if attack == '':
missile_rec = data[missile]
outf.write(', wielding {} [{}]'.format(
missile_rec['na'][0],
anchor(to_oid(u.return_unitid(missile_rec)))))
elif missile == '':
attack_rec = data[attack]
outf.write(', wielding {} [{}]'.format(
attack_rec['na'][0],
anchor(to_oid(u.return_unitid(attack_rec)))))
else:
missile_rec = data[missile]
attack_rec = data[attack]
outf.write(', wielding {} [{}] and {} [{}]'.format(
attack_rec['na'][0],
anchor(to_oid(u.return_unitid(attack_rec))),
missile_rec['na'][0],
anchor(to_oid(u.return_unitid(missile_rec)))))
if defense != '':
defense_rec = data[defense]
outf.write(', wearing {} [{}]'.format(
defense_rec['na'][0],
anchor(to_oid(u.return_unitid(defense_rec)))))
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 write_ships(v, k, data, outf):
outf.write('<li>\n')
outf.write('{} [{}], {}'.format(v['na'][0],
anchor(to_oid(k)),
u.return_type(v)))
if 'SL' in v:
if 'bs' in v['SL']:
storm = data[v['SL']['bs'][0]]
if 'na' in storm:
name = storm['na'][0]
else:
name = u.return_type(storm)
outf.write(', bound {}-storm {} [{}] (strength: {})'.format(u.return_type(storm),
name,
anchor(to_oid(v['SL']['bs'][0])),
storm['MI']['ss'][0]))
if 'SL' in v:
if 'de' in v['SL']:
outf.write(', defense {}'.format(v['SL']['de'][0]))
if 'eg' and 'er' in v['SL']:
effort_given = int(v['SL']['eg'][0])
effort_required = int(v['SL']['er'][0])
pct_complete = int(float(effort_given / effort_required)*100)
outf.write(', {}% completed'.format(pct_complete))
if 'da' in v['SL']:
outf.write(', {}% damaged'.format(v['SL']['da'][0]))
pct_load = ship.calc_pct_loaded(data, k, v)
if pct_load > 0:
outf.write(', {}% loaded'.format(pct_load))
if 'LI' in v and 'hl' in v['LI']:
sub_here_list = v['LI']['hl']
if len(sub_here_list) > 0:
first_here = data[sub_here_list[0]]
if u.return_kind(first_here) == 'char':
outf.write(', owner:')
outf.write('</li>\n')
# see if stuff stacked under it
if 'LI' in v and 'hl' in v['LI']:
sub_here_list = v['LI']['hl']
if len(sub_here_list) > 0:
outf.write('<ul>\n')
for sub_hl in sub_here_list:
sub_sub_here = data[sub_hl]
if u.return_kind(sub_sub_here) == 'loc':
write_sub_locs(v, sub_sub_here, sub_hl, data, outf)
elif u.return_kind(sub_sub_here) == 'char':
write_characters(sub_sub_here,
u.return_unitid(sub_sub_here),
data, outf)
outf.write('</ul>\n')
def write_ship_html(v, k, data, outdir):
# generate ship page
outf = open(pathlib.Path(outdir).joinpath(to_oid(k) + '.html'), 'w')
outf.write('<HTML>\n')
outf.write('<HEAD>\n')
outf.write('<TITLE>{} [{}], {}'.format(v['na'][0], to_oid(k),
u.return_type(v)))
outf.write('</TITLE>\n')
outf.write('</HEAD>\n')
outf.write('<BODY>\n')
write_ship_page_header(v, k, outf)
write_ship_basic_info(v, k, data, outf)
outf.write('</BODY>\n')
outf.write('</HTML>\n')
outf.close()
def write_unit_list(data, outf, v):
if 'PL' in v and 'un' in v['PL']:
unit_list = v['PL']['un']
unit_list.sort()
outf.write('<tr><td valign="top">Unit List:</td><td>')
outf.write('<table>\n')
columns = int(math.ceil(len(unit_list) / 3))
for unit in range(0, columns):
outf.write('<tr>')
if (columns * 0) + unit < len(unit_list):
char = data[unit_list[(columns * 0) + unit]]
if 'na' in char:
name = char['na'][0]
else:
name = u.return_type(char).capitalize()
if name == 'Ni':
name = data[char['CH']['ni'][0]]['na'][0].capitalize()
outf.write('<td>{} [{}]</td>'.format(name,
anchor(to_oid(u.return_unitid(char)))))
else:
outf.write('<td></td>')
if (columns * 1) + unit < len(unit_list):
char = data[unit_list[(columns * 1) + unit]]
if 'na' in char:
name = char['na'][0]
else:
name = u.return_type(char).capitalize()
if name == 'Ni':
name = data[char['CH']['ni'][0]]['na'][0].capitalize()
outf.write('<td>{} [{}]</td>'.format(name,
anchor(to_oid(u.return_unitid(char)))))
else:
outf.write('<td></td><td></td>')
if (columns * 2) + unit < len(unit_list):
char = data[unit_list[(columns * 2) + unit]]
if 'na' in char:
name = char['na'][0]
else:
name = u.return_type(char).capitalize()
if name == 'Ni':
name = data[char['CH']['ni'][0]]['na'][0].capitalize()
outf.write('<td>{} [{}]</td>'.format(name,
anchor(to_oid(u.return_unitid(char)))))
else:
outf.write('<td></td><td></td>')
outf.write('</tr>\n')
outf.write('</table>\n')
outf.write('</td></tr>')
def write_ship_non_prominent(v, k, data, outf):
seen_here_list = loop_here(data, k, False, True)
list_length = len(seen_here_list)
if list_length > 1:
first_time = True
printed_items = False
for un in seen_here_list:
unit_rec = data[un]
if 'il' in unit_rec:
item_list = unit_rec['il']
for items in range(0, len(item_list), 2):
item_rec = data[item_list[items]]
if 'IT' in item_rec and 'pr' in item_rec[
'IT'] and item_rec['IT']['pr'][0] == '1':
pass
else:
if int(item_list[items + 1]) > 0:
weight = 0
qty = int(item_list[items + 1])
if 'wt' in item_rec['IT']:
weight = int(item_rec['IT']['wt'][0])
total_weight = int(qty * weight)
if first_time and total_weight > 0:
outf.write(
'<p>Non-Prominent Items Onboard:</p>\n')
outf.write(
'<table border="1" cellpadding="5">\n')
outf.write(
'<tr><th>Possessor</th><th>Item</th><th>Qty</th><th>Weight</th></tr>'
)
first_time = False
if total_weight > 0:
printed_items = True
outf.write('<tr>')
outf.write('<td>{} [{}]</td>'.format(
unit_rec['na'][0], anchor(to_oid(un))))
outf.write('<td>{} [{}]</td>'.format(
item_rec['na'][0],
anchor(to_oid(item_list[items]))))
outf.write(
f'<td style="text-align:right">{qty:,d}</td>'
)
outf.write(
f'<td style="text-align:right">{total_weight:,d}</td>'
)
outf.write('</tr>\n')
if printed_items:
outf.write('</table>\n')
def get_pending_trades(v, data):
trades_list = []
if 'tl' in v:
trade_list = v['tl']
if len(trade_list) > 0:
for trades in range(0, len(trade_list), 8):
try:
itemz = data[trade_list[trades + 1]]
except KeyError:
pass
else:
direction = 'buy' if trade_list[trades] == '1' else 'sell'
price = int(trade_list[trades + 3])
qty = int(trade_list[trades + 2])
name = u.get_item_name(itemz) if int(
trade_list[trades +
2]) == 1 else u.get_item_plural(itemz)
oid = to_oid(trade_list[trades + 1])
trade_dict = {
'direction': direction,
'price': price,
'qty': qty,
'oid': oid,
'name': name
}
trades_list.append(trade_dict)
return trades_list
def write_player_html(v, k, data, outdir):
# generate player page
outf = open(pathlib.Path(outdir).joinpath(to_oid(k) + '.html'), 'w')
outf.write('<HTML>\n')
outf.write('<HEAD>\n')
name = v['na'][0]
outf.write('<TITLE>{} [{}]'.format(name,
to_oid(k)))
outf.write('</TITLE>\n')
outf.write('</HEAD>\n')
outf.write('<BODY>\n')
write_player_page_header(v, k, outf)
write_player_basic_info(v, data, outf)
outf.write('</BODY>\n')
outf.write('</HTML>\n')
outf.close()
def write_sub_locs(loc, sub_loc, k, data, outf):
outf.write('<li>')
outf.write('{} [{}], {}'.format(sub_loc['na'][0],
anchor(to_oid(k)),
u.return_type(sub_loc)))
if 'LO' in sub_loc and 'hi' in sub_loc['LO']:
outf.write(', hidden')
out_distance = u.calc_exit_distance(loc, sub_loc)
if out_distance > 0:
outf.write(', {} {}'.format(out_distance,
'day' if out_distance == 1 else 'days'))
if 'SL' in sub_loc and 'de' in sub_loc['SL']:
outf.write(', defense {}'.format(sub_loc['SL']['de'][0]))
if 'castle' in u.return_type(sub_loc):
if 'SL' in sub_loc:
if 'cl' in sub_loc['SL']:
if sub_loc['SL']['cl'][0] != '0':
outf.write(', level {}'.format(sub_loc['SL']['cl'][0]))
if 'mine' in u.return_type(sub_loc):
if 'SL' in sub_loc and 'sd' in sub_loc['SL']:
if sub_loc['SL']['sd'][0] != '0':
outf.write(', level {}'.format(int(sub_loc['SL']['sd'][0]) / 3))
if 'SL' in sub_loc:
if 'eg' and 'er' in sub_loc['SL']:
effort_given = int(sub_loc['SL']['eg'][0])
effort_required = int(sub_loc['SL']['er'][0])
pct_complete = int(float(effort_given / effort_required)*100)
outf.write(', {}% completed'.format(pct_complete))
if 'SL' in sub_loc and 'da' in sub_loc['SL']:
outf.write(', {}% damaged'.format(sub_loc['SL']['da'][0]))
if 'LI' in sub_loc and 'hl' in sub_loc['LI']:
sub_here_list = sub_loc['LI']['hl']
if len(sub_here_list) > 0:
first_here = data[sub_here_list[0]]
if u.return_kind(first_here) == 'char':
outf.write(', owner:')
outf.write('</li>\n')
# see if stuff stacked under it
if 'LI' in sub_loc and 'hl' in sub_loc['LI']:
sub_here_list = sub_loc['LI']['hl']
if len(sub_here_list) > 0:
outf.write('<ul>\n')
for sub_hl in sub_here_list:
sub_sub_here = data[sub_hl]
if u.return_kind(sub_sub_here) == 'loc':
write_sub_locs(sub_loc,
sub_sub_here,
sub_hl,
data,
outf)
elif u.return_kind(sub_sub_here) == 'char':
write_characters(sub_sub_here,
u.return_unitid(sub_sub_here),
data, outf)
elif u.return_kind(sub_sub_here) == 'ship':
write_ships(sub_sub_here,
u.return_unitid(sub_sub_here),
data,
outf)
outf.write('</ul>\n')
def get_priest_skills(v, data):
visions_list = []
skill_751 = None
skill_753 = None
if return_char_skill(v, '751') is not None:
skill_751 = True if return_char_skill(
v, '751')[0]['known'] == True else False
if return_char_skill(v, '753') is not None:
skill_753 = True if return_char_skill(
v, '753')[0]['known'] == True else False
if 'CM' in v and 'vi' in v['CM']:
vision_list = v['CM']['vi']
for vision in vision_list:
try:
visioned = data[vision]
except KeyError:
vision_name = 'missing'
vision_id = None
vision_oid = None
else:
vision_name = visioned.get('na', [u.return_kind(visioned)])[0]
vision_id = vision
vision_oid = to_oid(vision)
vision_dict = {
'id': vision_id,
'oid': vision_oid,
'name': vision_name
}
visions_list.append(vision_dict)
priest_dict = {
'skill751': skill_751,
'skill753': skill_753,
'visions': visions_list
}
return priest_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 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 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 write_cell(castle_chain, currentpoint, data, leftnav, outf, prefix,
rightnav, x, y, rem_width, rem_height, instance):
left_nav_dict = {}
if x == 0 and y == 0:
if leftnav:
printpoint = currentpoint - 10
left_nav_dict = {
'oid': to_oid(printpoint),
'width': 20,
'height': 840
}
cell = currentpoint + (x + (y * 100))
printpoint = str(cell)
try:
loc_rec = data[str(printpoint)]
except:
subkind = 'undefined'
border_dict = {}
contents_dict = {}
else:
subkind = u.return_subkind(loc_rec)
border_dict = generate_border(data, loc_rec, outf, instance)
contents_dict = generate_cell_contents(castle_chain, printpoint, data,
loc_rec, outf)
cell_dict = {
'oid': to_oid(printpoint),
'subkind': subkind,
'border_dict': border_dict,
'contents_dict': contents_dict
}
# except KeyError:
# outf.write('<td id="{}" class="x-sea">{}</td>\n'.format(to_oid(printpoint), to_oid(printpoint)))
right_nav_dict = {}
if x == 19 and y == 0:
if rightnav:
printpoint = currentpoint + 10
right_nav_dict = {
'oid': to_oid(printpoint),
'width': 20,
'height': 840
}
nav_dict = {
'left_nav_dict': left_nav_dict,
'cell_dict': cell_dict,
'right_nav_dict': right_nav_dict
}
return nav_dict
def write_cell(castle_chain, currentpoint, data, leftnav, outf, prefix,
rightnav, x, y, xx, yy, instance, map_matrix):
left_nav_dict = {}
if x == 0 and y == 0:
if leftnav:
printpoint = map_matrix[yy][xx - 10]
left_nav_dict = {
'oid': to_oid(printpoint),
'width': 20,
'height': 840
}
cell = map_matrix[yy + y][xx + x]
printpoint = cell
try:
loc_rec = data[str(printpoint)]
except:
type = 'undefined'
border_dict = {}
contents_dict = {}
else:
type = u.return_subkind(loc_rec)
border_dict = maps.generate_border(data, loc_rec, outf, instance)
contents_dict = maps.generate_cell_contents(castle_chain, printpoint,
data, loc_rec, outf)
cell_dict = {
'oid': to_oid(printpoint),
'type': type,
'border_dict': border_dict,
'contents_dict': contents_dict
}
# except KeyError:
# outf.write('<td id="{}" class="x-sea">{}</td>\n'.format(to_oid(printpoint), to_oid(printpoint)))
right_nav_dict = {}
if x == 19 and y == 0:
if rightnav:
printpoint = map_matrix[yy][xx + 10]
right_nav_dict = {
'oid': to_oid(printpoint),
'width': 20,
'height': 840
}
nav_dict = {
'left_nav_dict': left_nav_dict,
'cell_dict': cell_dict,
'right_nav_dict': right_nav_dict
}
return nav_dict
def write_skill_html(v, k, data, teaches_chain, child_skills_chain,
skills_known_chain, outdir):
# generate skill page
outf = open(pathlib.Path(outdir).joinpath(to_oid(k) + '.html'), 'w')
outf.write('<HTML>\n')
outf.write('<HEAD>\n')
name = v['na'][0]
outf.write('<TITLE>{} [{}]'.format(name, to_oid(k)))
outf.write('</TITLE>\n')
outf.write('</HEAD>\n')
outf.write('<BODY>\n')
write_skill_page_header(v, k, outf)
write_skill_basic_info(v, k, data, outf, teaches_chain, child_skills_chain,
skills_known_chain)
outf.write('</BODY>\n')
outf.write('</HTML>\n')
outf.close()
def write_char_location(data, outf, v):
if 'LI' in v and 'wh' in v['LI']:
loc = data[v['LI']['wh'][0]]
anch = anchor(to_oid(v['LI']['wh'][0]))
outf.write('<tr>')
outf.write('<td>Where:</td><td>{} [{}]</td>'.format(
loc['na'][0], anch))
outf.write('</tr>\n')
def write_char_faction(v, data, outf):
# CH/lo
if 'CH' in v and 'lo' in v['CH']:
player = data[v['CH']['lo'][0]]
outf.write('<tr>')
outf.write('<td>Faction:</td>')
outf.write('<td>{} [{}]</td></tr>\n'.format(
player['na'][0], anchor(to_oid(u.return_unitid(player)))))
def write_char_pledged_to(v, data, outf):
# CM/pl
if 'CM' in v and 'pl' in v['CM']:
pledged_to = data[v['CM']['pl'][0]]
outf.write('<tr>')
outf.write('<td>Pledged To:</td>')
outf.write('<td>{} [{}]</td></tr>\n'.format(
pledged_to['na'][0], anchor(to_oid(u.return_unitid(pledged_to)))))
