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 get_civ_level(k, v, data):
civ_level = None
if not u.is_ocean(v) and u.loc_depth(u.return_subkind(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]
return civ_level
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 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_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 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 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 write_hidden_access(v, k, data, outf, hidden_chain):
if 'LO' in v and 'hi' in v['LO']:
if v['LO']['hi'][0] == '1' or u.region(k, data) in {'faery', 'hades'}:
# PL/kn
try:
hidden_list = hidden_chain[k]
if len(hidden_list) > 0:
outf.write('Hidden location known by:</H4>\n')
outf.write('<ul>\n')
for hidden in hidden_list:
hidden_rec = data[hidden]
outf.write('<li>{} [{}]</td></li>\n'.format(hidden_rec['na'][0],
anchor(to_oid(hidden))))
outf.write('</ul>\n')
finally:
pass
def get_hidden_access(k, v, data, hidden_chain):
hidden_access_list = []
if u.is_hidden(v) or u.region(k, data) in {'faery', 'hades'}:
# PL/kn
try:
hidden_list = hidden_chain[k]
except:
pass
else:
if len(hidden_list) > 0:
for hidden in hidden_list:
hidden_rec = data[hidden]
hidden_dict = {'oid': to_oid(hidden),
'name': get_name(hidden_rec)}
hidden_access_list.append(hidden_dict)
return hidden_access_list
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 get_taught_in(k, v, data, teaches_chain):
taught_in_list = []
skill_list = teaches_chain[k]
if len(skill_list) > 0:
for loc in skill_list:
loc_rec = data[loc]
where_id = loc_rec['LI']['wh'][0]
where_rec = data[where_id]
region_id = u.region(u.return_unitid(where_rec), data)
region_rec = data[region_id]
loc_dict = {
'id': loc,
'oid': to_oid(loc),
'name': get_name(loc_rec),
'where_id': where_id,
'where_oid': to_oid(where_id),
'where_name': get_name(where_rec),
'region_id': region_id,
'region_oid': to_oid(region_id),
'region_name': get_name(region_rec)
}
taught_in_list.append(loc_dict)
return taught_in_list
def write_skill_basic_info(v, k, data, outf, teaches_chain, child_skills_chain,
skills_known_chain):
outf.write('<table>\n')
if 'SK' in v:
if 'rs' in v['SK']:
skill = data[v['SK']['rs'][0]]
outf.write('<tr><td>Skill Required:</td><td>{} [{}]'
'</td></tr>\n'.format(skill['na'][0],
anchor(u.return_unitid(skill))))
if 'tl' in v['SK']:
outf.write('<tr><td>Time to Learn:</td><td>{}</td></tr>\n'.format(
v['SK']['tl'][0]))
char_list = skills_known_chain[k]
if len(char_list) > 0:
outf.write('<tr><td valign="top">Known By:</td><td>')
outf.write('<table>\n')
columns = int(math.ceil(len(char_list) / 3))
for charac in range(0, columns):
outf.write('<tr>')
if (columns * 0) + charac < len(char_list):
char_rec = data[char_list[(columns * 0) + charac]]
outf.write('<td>{} [{}]</td>'.format(
char_rec['na'][0],
anchor(to_oid(u.return_unitid(char_rec)))))
else:
outf.write('<td></td><td></td>')
if (columns * 1) + charac < len(char_list):
char_rec = data[char_list[(columns * 1) + charac]]
outf.write('<td>{} [{}]</td>'.format(
char_rec['na'][0],
anchor(to_oid(u.return_unitid(char_rec)))))
else:
outf.write('<td></td><td></td>')
if (columns * 2) + charac < len(char_list):
char_rec = data[char_list[(columns * 2) + charac]]
outf.write('<td>{} [{}]</td>'.format(
char_rec['na'][0],
anchor(to_oid(u.return_unitid(char_rec)))))
else:
outf.write('<td></td><td></td>')
outf.write('</tr>\n')
outf.write('</table>\n')
outf.write('</td></tr>')
child_list = child_skills_chain[k]
if len(child_list) > 0:
outf.write('<tr><td valign="top">Child Skills:</td><td>')
outf.write('<table>\n')
columns = int(math.ceil(len(child_list) / 3))
for skill in range(0, columns):
outf.write('<tr>')
if (columns * 0) + skill < len(child_list):
skill_rec = data[child_list[(columns * 0) + skill]]
outf.write('<td>{} [{}]</td>'.format(
skill_rec['na'][0],
anchor(to_oid(u.return_unitid(skill_rec)))))
else:
outf.write('<td></td><')
if (columns * 1) + skill < len(child_list):
skill_rec = data[child_list[(columns * 1) + skill]]
outf.write('<td>{} [{}]</td>'.format(
skill_rec['na'][0],
anchor(to_oid(u.return_unitid(skill_rec)))))
else:
outf.write('<td></td>')
if (columns * 2) + skill < len(child_list):
skill_rec = data[child_list[(columns * 2) + skill]]
outf.write('<td>{} [{}]</td>'.format(
skill_rec['na'][0],
anchor(to_oid(u.return_unitid(skill_rec)))))
else:
outf.write('<td></td>')
outf.write('</tr>\n')
outf.write('</table>\n')
outf.write('</td></tr>')
skill_list = teaches_chain[k]
if len(skill_list) > 0:
skill_literal = 'Taught in:'
for loc in skill_list:
loc_rec = data[loc]
where_rec = data[loc_rec['LI']['wh'][0]]
region = data[u.region(u.return_unitid(where_rec), data)]
outf.write(
'<tr><td>{}</td><td>{} [{}], {} [{}], in {}</td></tr>\n'.
format(skill_literal, loc_rec['na'][0],
anchor(to_oid(u.return_unitid(loc_rec))),
where_rec['na'][0],
anchor(to_oid(u.return_unitid(where_rec))),
region['na'][0]))
skill_literal = ''
outf.write('</table>\n')
def write_province_destination(loc, dest_loc, direction, data, outf):
if (u.is_port_city(dest_loc, data) or u.province_has_port_city(dest_loc, data) != '0') \
and u.return_type(loc) == 'ocean':
if not u.is_port_city(dest_loc, data):
dest_loc = data[u.province_has_port_city(dest_loc, data)]
dest_loc_host = data[dest_loc['LI']['wh'][0]]
outf.write('<li>{}, port city, to {} [{}]'
.format(direction,
dest_loc['na'][0],
anchor(to_oid(u.return_unitid(dest_loc)))))
if u.region(u.return_unitid(loc), data) != u.region(u.return_unitid(dest_loc), data):
region_key = u.return_unitid(dest_loc)
region_rec = data[u.region(region_key, data)]
outf.write(', {}'.format(region_rec['na'][0]))
barrier = '0'
if 'LO' in dest_loc and 'ba' in dest_loc['LO']:
barrier = dest_loc['LO']['ba'][0]
if barrier != '0':
outf.write(', impassable<br> A magical barrier prevents entry.')
else:
out_distance = u.calc_exit_distance(loc, dest_loc)
outf.write(', {} {}'.format(out_distance,
'day' if out_distance == 1 else 'days'))
outf.write('</li>\n')
outf.write('<li> {}, to {} [{}]'.format(direction,
dest_loc_host['na'][0],
anchor(to_oid(u.return_unitid(dest_loc_host)))))
if u.region(u.return_unitid(loc), data) != \
u.region(u.return_unitid(dest_loc), data):
region_key = u.return_unitid(dest_loc_host)
region_rec = data[u.region(region_key, data)]
outf.write(', {}'.format(region_rec['na'][0]))
barrier = '0'
if 'LO' in dest_loc_host and 'ba' in dest_loc_host['LO']:
barrier = dest_loc_host['LO']['ba'][0]
if barrier != '0':
outf.write(', impassable<br> A magical barrier prevents entry.')
else:
outf.write(', impassable')
outf.write('</li>\n')
else:
outf.write('<li>{}'.format(direction))
if direction == 'Out':
outf.write(', {}'.format(u.return_type(dest_loc)))
outf.write(', to {} [{}]'.format(dest_loc['na'][0],
anchor(to_oid(u.return_unitid(dest_loc)))))
if u.region(u.return_unitid(loc), data) != \
u.region(u.return_unitid(dest_loc), data):
region_key = u.return_unitid(dest_loc)
region_rec = data[u.region(region_key, data)]
outf.write(', {}'.format(region_rec['na'][0]))
barrier = '0'
if 'LO' in dest_loc and 'ba' in dest_loc['LO']:
barrier = dest_loc['LO']['ba'][0]
if barrier != '0':
outf.write(', impassable<br> A magical barrier prevents entry.')
elif (u.return_type(loc) == 'ocean' and \
u.return_type(dest_loc) == 'mountain') or \
(u.return_type(loc) == 'mountain' and \
u.return_type(dest_loc) == 'ocean') and \
direction.lower() not in details.road_directions:
outf.write(', impassable')
else:
out_distance = u.calc_exit_distance(loc, dest_loc)
outf.write(', {} {}'.format(out_distance,
'day' if out_distance == 1 else 'days'))
if dest_loc['na'][0] == 'Hades' and loc['na'][0] != 'Hades':
outf.write('<br> "Notice to all mortals, from the Gatekeeper '
'Spirit of Hades: 100 gold/head<br> '
'is removed from any stack taking this road"')
outf.write('</li>\n')
def get_map_anchor(v, k, data, instance, inst_dict, map_matrices):
if u.return_subkind(v) in ['tunnel', 'chamber']:
return None
dimensions = inst_dict[instance]
region = u.region(k, data)
region_rec = data[region]
province = u.province(k, data)
if province == 0:
return None
province_rec = data[province]
custom = False
save_rec = []
save_world = ''
try:
save_rec = map_matrices[region_rec['na'][0].lower()]
except KeyError:
try:
save_rec = dimensions[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
else:
save_world = region_rec['na'][0].lower()
else:
save_world = region_rec['na'][0].lower()
custom = True
# if len(save_rec) == 0:
# print('error {} {}'.format(to_oid(k),
# u.return_subkind(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)
return anchor_string
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)
return anchor_string
return None
def get_destinations(k, v, data):
dest_list = []
if 'LO' in v and 'pd' in v['LO']:
pd_list = v['LO']['pd']
i = int(0)
for pd in pd_list:
if pd != '0':
direction = pd_directions[i]
pd_rec = data[pd]
region_id = u.region(pd, data)
region_rec = data[region_id]
if u.province_has_port_city(pd_rec, data) is not None:
city_rec = data[u.province_has_port_city(pd_rec, data)]
to_dict = create_loc_to_dict_entry(data, direction, city_rec, v, region_rec)
dest_list.append(to_dict)
to_dict = create_loc_to_dict_entry(data, direction, pd_rec, v, region_rec)
dest_list.append(to_dict)
# see if port city so show province also
if u.is_port_city(pd_rec, data):
prov_rec = data[u.province(pd, data)]
to_dict = create_loc_to_dict_entry(data, direction, prov_rec, v, region_rec)
dest_list.append(to_dict)
i = i + 1
if u.return_subkind(v) not in details.province_kinds:
if 'LI' in v and 'wh' in v['LI']:
out_id = v['LI']['wh'][0]
out_rec = data[out_id]
region_id = u.region(out_id, data)
region_rec = data[region_id]
to_dict = create_loc_to_dict_entry(data, 'Out', out_rec, v, region_rec)
dest_list.append(to_dict)
if 'LI' in v and '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_id = here_record['GA']['tl'][0]
to_rec = data[to_id]
region_id = u.region(to_id, data)
region_rec = data[region_id]
if u.return_kind(here_record) == 'gate':
direction = 'Gate'
else:
direction = get_name(here_record)
to_dict = create_loc_to_dict_entry(data, direction, to_rec, here_record, region_rec)
dest_list.append(to_dict)
if 'SL' in v and 'lt' in v['SL']:
link_id = v['SL']['lt'][0]
link_rec = data[link_id]
region_id = u.region(link_id, data)
region_rec = data[region_id]
to_dict = create_loc_to_dict_entry(data, get_subkind(link_rec, data).title(), link_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
