def get_localisation(key, game, process_substitutions = True):
"""
process_substitutions: If true, items between $ signs will be replaced with the localisation with that key.
"""
def replace_substitution(m):
return get_localisation(m.group(1), game, process_substitutions = True) or ''
if game not in localisation_cache:
localisation_path = os.path.join(pyradox.get_game_directory(game), 'localisation')
localisation_cache[game] = parse_walk(localisation_path)
if key.lower() in localisation_cache[game]:
result = pyradox.token.make_string(localisation_cache[game][key.lower()])
if process_substitutions:
# TODO: are $ signs escapable?
result = re.sub(r'\$(.*?)\$', replace_substitution, result)
return result
else:
return None
def get_localisation(key, game, process_substitutions=True):
"""
process_substitutions: If true, items between $ signs will be replaced with the localisation with that key.
"""
def replace_substitution(m):
return get_localisation(m.group(1), game,
process_substitutions=True) or ''
if game not in localisation_cache:
localisation_path = os.path.join(pyradox.get_game_directory(game),
'localisation')
localisation_cache[game] = parse_walk(localisation_path)
if key.lower() in localisation_cache[game]:
result = pyradox.token.make_string(
localisation_cache[game][key.lower()])
if process_substitutions:
# TODO: are $ signs escapable?
result = re.sub(r'\$(.*?)\$', replace_substitution, result)
return result
else:
return None
import hoi4
import os
import re
import collections
import pyradox
from PIL import Image
# Load states.
states = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'states'), verbose=False)
# provinces -> state id
groups = {}
for state in states.values():
k = tuple(province_id for province_id in state.find_all('provinces'))
groups[k] = str(state['id'])
# Load the province map using the default location set in pyradox.
province_map = pyradox.worldmap.ProvinceMap(game = 'HoI4')
out = province_map.generate_image({}, default_land_color=(255, 255, 255), edge_groups = groups.keys())
pyradox.image.save_using_palette(out, 'out/blank_state_map.png')
import _initpath
import pyradox
import os
from PIL import Image
province_map = pyradox.worldmap.ProvinceMap()
terrain_map_image = Image.open('in/terrain.png')
terrain_txt = pyradox.txt.parse_file(os.path.join(os.path.join(pyradox.get_game_directory('EU4'), 'map', 'terrain.txt')))
terrain_by_color = {}
for terrain_name, terrain in terrain_txt['categories'].items():
if 'color' in terrain:
color = tuple(terrain['color'])
terrain_by_color[color] = (terrain_name, terrain)
def get_province_terrain(province_id):
position = province_map.positions[province_id]
color = terrain_map_image.getpixel(position)
return terrain_by_color[tuple(color)]
import _initpath
import os
import re
import collections
from PIL import Image
import pyradox
tree = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'map', 'terrain.txt'))
terrain_bmp = Image.open(os.path.join(pyradox.get_game_directory('EU4'), 'map', 'terrain.bmp'))
print(terrain_bmp.getpalette())
province_map = pyradox.worldmap.ProvinceMap()
colormap = {}
for province_id, position in province_map.positions.items():
print(province_id)
colormap[province_id] = tuple(terrain_bmp.getpixel(position))
for terrain_type, terrain_data in tree['categories'].items():
if 'color' not in terrain_data: continue
color = tuple(terrain_data.find_all('color'))
for province_id in terrain_data.find_all('terrain_override'):
colormap[province_id] = color
out = province_map.generate_image(colormap)
out.save('out/terrain_map.png')
import pyradox
import province_costs
sources = ['EU4', 'text', 'nw2', 'res_publica', "aow"]
def localized(s):
return pyradox.yml.get_localisation(s) or pyradox.format.human_title(s)
culture_groups = {}
culture_tree = pyradox.txt.parse_file(
os.path.join(pyradox.get_game_directory('EU4'), 'common', 'cultures',
'00_cultures.txt'))
for group_name, group_data in culture_tree.items():
for culture in group_data:
culture_groups[culture] = group_name
culture_data = {}
culture_group_data = {}
for filename, data in pyradox.txt.parse_dir(os.path.join(
pyradox.get_game_directory('EU4'), 'history', 'provinces'),
verbose=False):
data = data.at_date(pyradox.Date('1444.11.11'))
if 'culture' not in data:
if 'base_tax' in data:
print_string += other_tech_key + ', '
print_string = print_string[:-2] + '.'
else:
print_string += ', needs one of: '
for other_tech_key in techs_or_dependencies[tech_key]:
print_string += other_tech_key + ', '
print_string = print_string[:-2] + '.'
print(print_string)
def check_years(tech_keys, filename, date):
for tech_key in tech_keys:
tech = techs[tech_key]
if (tech['start_year'] or 0) > date.year:
print('%s : %s : Tech %s is ahead of time with year %s' % (filename, date, tech_key, tech['start_year']))
for filename, country in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'countries')):
tech_keys = set(country['set_technology'].keys())
check_deps(tech_keys, filename, pyradox.Date('1936.1.1'))
for date, effects in country.items():
if not isinstance(date, pyradox.Date): continue
if 'set_technology' not in effects: continue
tech_keys |= set(effects['set_technology'].keys())
check_deps(tech_keys, filename, date)
for filename, country in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'countries')):
tech_keys = set(country['set_technology'].keys())
check_years(tech_keys, filename, pyradox.Date('1936.1.1'))
for date, effects in country.items():
if not isinstance(date, pyradox.Date): continue
if 'set_technology' not in effects: continue
tech_keys |= set(effects['set_technology'].keys())
import _initpath
import os
import re
import collections
from PIL import Image
import pyradox
base_bmp = os.path.join(pyradox.get_game_directory('EU4'), 'map', 'rivers.bmp')
rivers_map = Image.open(base_bmp).convert('RGB')
province_map = pyradox.worldmap.ProvinceMap()
province_map.overlay_edges(rivers_map)
rivers_map.save('out/rivers_map.png')
import pyradox
def get_stability_likely(conditions):
result = [0 for x in range(7)]
for stability in conditions.find_all("stability"):
result[stability] = 1
for not_condition in conditions.find_all("NOT"):
for stability in not_condition.find_all("stability"):
result[stability] = -1
return result
events_tree = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'events', 'Republics.txt'))
allow_events = list(list([] for x in range(3)) for x in range(7))
likely_events = list(list([] for x in range(3)) for x in range(7))
for event in events_tree.find_all("country_event"):
event_name = pyradox.yml.get_localisation(event["title"])
if "trigger" in event:
allow = get_stability_likely(event["trigger"])
for i, x in enumerate(allow):
if event_name not in allow_events[i][x]:
allow_events[i][x].append(event_name)
if "mean_time_to_happen" in event:
likelies = [0] * 7
for modifier in event["mean_time_to_happen"].find_all("modifier"):
import _initpath
import os
import re
import collections
import pyradox
province_map = pyradox.worldmap.ProvinceMap(pyradox.get_game_directory('HoI3'), flip_y = True)
colormap = {}
out = province_map.generate_image(colormap, default_land_color=(255, 255, 255))
pyradox.image.save_using_palette(out, 'out/blank_map.png')
import hoi4
import os
import math
import re
import collections
import pyradox
from PIL import Image
# Load states.
states = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'states'), verbose=False)
state_categories = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory('HoI4'), 'common', 'state_category'), merge_levels = 1, verbose=False)
state_categories = state_categories['state_categories']
province_map = pyradox.worldmap.ProvinceMap(game = 'HoI4')
# provinces -> state id
groups = {}
colormap = {}
for state in states.values():
state_category_key = state['state_category']
building_slots = state_categories[state_category_key]['local_building_slots'] or 0
k = []
for province_id in state.find_all('provinces'):
if not province_map.is_water_province(province_id):
k.append(province_id)
colormap[province_id] = pyradox.image.colormap_red_green(building_slots / 10)
k = tuple(x for x in k)
import re
import os
import hoi4
import pyradox
def compute_country_tag_and_name(filename):
m = re.match('.*([A-Z]{3})\s*-\s*(.*)\.txt$', filename)
return m.group(1), m.group(2)
countries = {}
for filename, country in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'countries')):
tag, name = compute_country_tag_and_name(filename)
country['tag'] = tag
ruling_party = country['set_politics']['ruling_party'] or 'neutrality'
country['name'] = pyradox.yml.get_localisation('%s_%s' % (tag, ruling_party), game = 'HoI4')
if country['name'] is None: print(tag)
countries[tag] = country
advisor_types = [
'political_advisor',
]
company_types = [
'tank_manufacturer',
'naval_manufacturer',
'aircraft_manufacturer',
idea_name = pyradox.yml.get_localisation(idea)
title = '%s %d: %s' % (ig_name, idx, idea_name)
for bonus, value in bonuses.items():
add_bonus(bonus, title, value)
idx += 1
def make_wiki_table(bonus):
result = '<table class = "wikitable sortable">\n'
result += ' <tr><th width="400px">Idea</th><th>Modifier</th></tr>\n'
for value, title in bonus_sources[bonus]:
result += ' <tr><td>%s</td><td>%s</td></tr>\n' % (title, value_string(bonus, value))
result += '</table>\n'
return result
for _, data in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('EU4'), 'common', 'ideas')):
for key, tree in data.items():
process_idea_group(key, tree)
for bonus in ideaoptions.bonus_types:
if bonus not in bonus_sources.keys():
print("No sources:" + bonus)
print()
wiki_page = ''
for bonus in sorted(bonus_sources.keys()):
sources = ['EU4', 'text', 'modifers', 'powers_and_ideas', 'nw2', 'res_publica', "aow"]
bonus_title = (
pyradox.yml.get_localisation('modifier_%s' % bonus)
or pyradox.yml.get_localisation('yearly_%s' % bonus)
import _initpath
import os
import pyradox
result_tree = pyradox.Tree()
for group_name, group_data in pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory('EU4'), 'common', 'ideas')).items():
if 'trigger' not in group_data: continue
trigger = group_data['trigger']
for tag in trigger.find_all('tag'):
result_tree[tag] = group_name
if 'or' in trigger:
for tag in trigger['or'].find_all('tag'):
result_tree[tag] = group_name
outfile = open('out/idea_map.txt', mode = 'w')
outfile.write(str(result_tree))
outfile.close()
import _initpath
import os
import pyradox
# Parse the military tech file.
tree = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'common', 'technologies', 'mil.txt'))
# Base statistics.
stats = {
'land_morale' : 0.0,
'military_tactics' : 0.5,
'infantry_fire' : 0.0,
'infantry_shock' : 0.0,
'cavalry_fire' : 0.0,
'cavalry_shock' : 0.0,
'artillery_fire' : 0.0,
'artillery_shock' : 0.0,
'combat_width' : 15,
'supply_limit' : 0.0,
}
w = '{| class = "wikitable"\n'
w += '! rowspan = "2" | Tech level !! rowspan = "2" | Year !! rowspan = "2" | Morale !! rowspan = "2" | Military<br/>Tactics '
w += '!! colspan = "2" | Infantry !! colspan = "2" | Cavalry !! colspan = "2" | Artillery '
w += '!! rowspan = "2" | Combat<br/>Width !! rowspan = "2" | Supply<br/>Limit '
w += '\n|-\n'
w += '! Fire !! Shock !! Fire !! Shock !! Fire !! Shock\n'
b = values[2]
return (r, g, b)
else:
# hsv
return pyradox.image.HSVtoRGB(values)
date = pyradox.Date('1936.1.1')
scale = 2.0
# state_id -> [tag]
capital_states = {}
country_colors = {}
country_color_file = pyradox.txt.parse_file(
os.path.join(pyradox.get_game_directory('HoI4'), 'common', 'countries',
'colors.txt'))
for filename, country in pyradox.txt.parse_dir(
os.path.join(pyradox.get_game_directory('HoI4'), 'history',
'countries')):
tag = compute_country_tag(filename)
if tag in country_color_file:
country_colors[tag] = compute_color(
tuple(country_color_file[tag].find_all('color')))
else:
print('HACK FOR %s' % tag)
country_colors[tag] = (165, 102, 152)
print(tag, country_colors[tag])
if country['capital'] not in capital_states:
capital_states[country['capital']] = []
r = values[0]
g = values[1]
b = values[2]
return (r, g, b)
else:
# hsv
return pyradox.image.HSVtoRGB(values)
# find all capitals and country colors
# state_id -> [tag]
capital_states = {}
country_colors = {}
country_color_file = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('HoI4'), 'common', 'countries', 'colors.txt'))
for filename, country in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'countries')):
tag = compute_country_tag(filename)
if tag in country_color_file:
country_colors[tag] = country_color_file[tag]['color'].to_rgb()
else:
print('HACK FOR %s' % tag)
country_colors[tag] = (165, 102, 152)
print(tag, country_colors[tag])
if country['capital'] not in capital_states: capital_states[country['capital']] = []
capital_states[country['capital']].append(tag)
# Load states.
states = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'states'))
province_map = pyradox.worldmap.ProvinceMap(game = 'HoI4')
import hoi4
import os
import re
import collections
import pyradox
from PIL import Image
# Load states.
states = pyradox.txt.parse_merge(os.path.join(
pyradox.get_game_directory('HoI4'), 'history', 'states'),
verbose=False)
# provinces -> state id
groups = {}
for state in states.values():
k = tuple(province_id for province_id in state.find_all('provinces'))
groups[k] = str(state['id'])
# Load the province map using the default location set in pyradox.
province_map = pyradox.worldmap.ProvinceMap(game='HoI4')
out = province_map.generate_image({},
default_land_color=(255, 255, 255),
edge_groups=groups.keys())
pyradox.image.save_using_palette(out, 'out/blank_state_map.png')
import _initpath
import os
import re
import collections
from PIL import Image
import pyradox
base_bmp = os.path.join(pyradox.get_game_directory('EU4'), 'map', 'rivers.bmp')
rivers_map = Image.open(base_bmp).convert('RGB')
province_map = pyradox.worldmap.ProvinceMap()
province_map.overlay_edges(rivers_map)
rivers_map.save('out/rivers_map.png')
import _initpath
import os
import pyradox
result_tree = pyradox.Tree()
for group_name, group_data in pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory('EU4'), 'common', 'ideas')).items():
if 'trigger' not in group_data: continue
trigger = group_data['trigger']
for tag in trigger.find_all('tag'):
result_tree[tag] = group_name
if 'or' in trigger:
for tag in trigger['or'].find_all('tag'):
result_tree[tag] = group_name
outfile = open('out/idea_map.txt', mode = 'w')
outfile.write(str(result_tree))
outfile.close()
import _initpath
import os
import re
import collections
import pyradox
tree = pyradox.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'common', 'wargoal_types', '00_wargoal_types.txt'))
def left_columns(wargoal, data, side = None):
result = '|-\n'
if side is None:
result += '| %s\n' % pyradox.format.human_string(wargoal, True)
else:
result += '| %s (%s)\n' % (pyradox.format.human_string(wargoal, True), side)
result += '| %s\n' % pyradox.format.human_string(data["type"], True)
if 'allow_leader_change' in data:
result += '| {{Icon|yes}}\n'
else:
result += '| {{Icon|no}}\n'
return result
def right_columns(wargoal, po_data):
result = ''
result += '| %d%%\n' % (po_data['badboy_factor'] * 100)
result += '| %d%%\n' % (po_data['prestige_factor'] * 100)
result += '| %d%%\n' % (po_data['peace_cost_factor'] * 100)
import hoi4
import csv
import os
import re
import collections
import pyradox
static_modifiers = pyradox.txt.parse_file(
os.path.join(pyradox.get_game_directory('HoI4'), 'common',
'static_modifiers.txt'))
def compute_name(k, v):
return pyradox.format.human_string(k.replace('weather_', ''),
cap_first=True)
def is_precipitation(k, v):
return 'weather' in k and 'air_accidents' in v
def is_temperature(k, v):
return 'cold' in k or 'hot' in k
def is_ground_effect(k, v):
return 'mud' in k or 'ground_snow' in k
def is_weather(k, v):
legend = ''
for name, color in color_defs.items():
bg_color_string = '#%02x%02x%02x' % color
r, g, b = color
y = 0.2126 * r + 0.7152 * g + 0.0722 * b
if y >= 255 / 2:
text_color_string = '#000000'
else:
text_color_string = '#ffffff'
legend += '<span style="color:%s; background-color:%s">%s </span>' % (text_color_string, bg_color_string, name)
print(legend)
climate_map = {}
for climate, provinces in pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'map', 'climate.txt'), verbose=False).items():
for province_id in provinces:
if climate in color_defs.keys():
climate_map[province_id] = climate
colormap = {}
for filename, data in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('EU4'), 'history', 'provinces'), verbose=False):
m = re.match('\d+', filename)
province_id = int(m.group(0))
if 'base_tax' not in data: continue # skip wastelands
if province_id in climate_map:
colormap[province_id] = color_defs[climate_map[province_id]]
else:
colormap[province_id] = color_defs['default']
province_map = pyradox.worldmap.ProvinceMap()
import hoi4
import os
import re
import collections
import pyradox
from PIL import Image
scale = 3
# Load states.
states = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'states'))
srs = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory('HoI4'), 'map', 'strategicregions'))
province_map = pyradox.worldmap.ProvinceMap(game = 'HoI4')
# state id -> provinces
state_groups = {}
for state in states.values():
group = tuple(province_id for province_id in state.find_all('provinces'))
if len(group) > 0: state_groups[state['id']] = group
sr_groups = []
for sr in srs.values():
# may have empty group
group = tuple(province_id for province_id in sr.find_all('provinces') if isinstance(province_id, int))
if len(group) > 0: sr_groups.append(group)
import _initpath
import os
import pyradox
colormap = {}
tree = pyradox.txt.parse_file(
os.path.join(pyradox.get_game_directory('EU4'), 'decisions', 'Muslim.txt'))
unify_requirements = tree['country_decisions']['unify_islam']['allow']
for province_id in unify_requirements.find_all('owns_or_vassal_of'):
colormap[province_id] = (0, 127, 0)
province_map = pyradox.worldmap.ProvinceMap()
out = province_map.generate_image(colormap)
out.save('out/unify_islam_map.png')
import _initpath
import os
import re
import collections
import pyradox
from PIL import Image
# Load the province map using the default location set in pyradox.
province_map = pyradox.worldmap.ProvinceMap()
colormap = {}
for filename, data in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('EU4'), 'history', 'provinces'), verbose=False):
m = re.match('\d+', filename)
province_id = int(m.group(0))
if ('base_tax' in data and data['base_tax'] > 0):
colormap[province_id] = (150, 150, 150)
# Create a blank map and scale it up 2x.
out = province_map.generate_image(colormap, default_land_color=(97, 97, 97), default_water_color=(68, 107, 163), edge_color=(255, 255, 255))
out = out.resize((out.size[0] * 2, out.size[1] * 2), Image.NEAREST)
# Create the map labels.
textmap = {}
colormap = {}
for province_id in province_map.positions.keys():
textmap[province_id] = '%d' % province_id
if province_map.is_water_province(province_id):
colormap[province_id] = (0, 0, 0)
def __init__(self, game, flip_y = False):
"""Creates a province map using the base game directory specified, defaulting to the one in pyradox.config."""
self.game = game
basedir = pyradox.get_game_directory(game)
provinces_bmp = os.path.join(basedir, 'map', 'provinces.bmp')
definition_csv = os.path.join(basedir, 'map', 'definition.csv')
default_map = os.path.join(basedir, 'map', 'default.map')
self.province_image = Image.open(provinces_bmp)
if flip_y:
self.province_image = self.province_image.transpose(Image.FLIP_TOP_BOTTOM)
with open(definition_csv) as definition_file:
csv_reader = csv.reader(definition_file, delimiter = ';')
self.province_color_by_id = {}
self.province_id_by_color = {}
self.water_provinces = set()
self._adjacency = {} # lazy evaluation
water_keys = ('sea_starts', 'lakes')
default_tree = pyradox.parse_file(default_map, verbose=False)
max_province = default_tree['max_provinces']
for key in water_keys:
for province_id in default_tree.find_all(key):
self.water_provinces.add(province_id)
province_count = 0
for row in csv_reader:
try:
province_id = int(row[0])
province_color = (int(row[1]), int(row[2]), int(row[3]))
if row[4] in ("sea", "lake"): self.water_provinces.add(province_id) # HoI4
self.province_color_by_id[province_id] = province_color
self.province_id_by_color[province_color] = province_id
province_count += 1
except ValueError:
warnings.warn('Could not parse province definition from row "%s" of %s.' % (str(row), definition_csv))
pass
print("Read %d provinces from %s." % (province_count, definition_csv))
self.positions = {}
self.positions['centroid'] = { province_id : (0.0, 0.0) for province_id in self.province_color_by_id.keys() }
self.province_sizes = { province_id : 0 for province_id in self.province_color_by_id.keys() }
# compute province sizes and centroids (assume no provinces wrap around)
for index, pixel in enumerate(self.province_image.getdata()):
x = index % self.province_image.size[0]
y = index // self.province_image.size[0]
province_id = self.province_id_by_color[pixel]
self.province_sizes[province_id] += 1
prev_x, prev_y = self.positions['centroid'][province_id]
self.positions['centroid'][province_id] = (prev_x + x, prev_y + y)
for province_id in self.positions['centroid'].keys():
size = self.province_sizes[province_id]
if size > 0:
prev_x, prev_y = self.positions['centroid'][province_id]
self.positions['centroid'][province_id] = (prev_x / size, prev_y / size)
else:
warnings.warn('Province %d has size 0.' % province_id)
print('Computed province centroids.')
max_y = self.province_image.size[1] # use image coords
if 'HoI4' in game:
building_headings = ['state_id', 'type', 'x', 'x_offset', 'y', 'y_offset', 'sea_province_id']
buildings = pyradox.csv.parse_file(['map', 'buildings.txt'], game = game, headings = building_headings)
for _, row in buildings.items():
building_type = row['type']
x, y = int(row['x']), max_y - int(row['y'])
province_id = self.province_at_coordinates(x, y)
if building_type not in self.positions: self.positions[building_type] = {}
self.positions[building_type][province_id] = (row['x'], max_y - row['y'])
"""
unitstack_headings = ['province_id', 'type', 'x', 'x_offset', 'y', 'y_offset', 'z']
self.positions['unitstacks'] = {}
unitstacks = pyradox.csv.parse_file(['map', 'unitstacks.txt'], game = game, headings = unitstack_headings)
for province_id, row in unitstacks.items():
self.positions['unitstacks'][province_id] = (row['x'], max_y - row['y'])
"""
print('Read province positions.')
"""
def parse_walk(dirname, verbose=False):
"""Given a directory, recursively iterate over the content of the .txt files in that directory as Trees"""
skip = '\\\\(map|wiki|interface|pdx_launcher|previewer_assets)\\\\'
start_time = time.clock()
file_count = 0
do_txt = True
do_yml = True
dirname = os.path.join(pyradox.get_game_directory('HoI4'))
for root, dirs, files in os.walk(dirname):
if root == dirname: continue
for filename in files:
fullpath = os.path.join(root, filename)
if re.search(skip, fullpath): continue
_, ext = os.path.splitext(fullpath)
if do_txt and ext == '.txt':
try:
pyradox.parse_file(fullpath)
file_count += 1
except:
print(sys.exc_info())
elif do_yml and ext == '.yml':
try:
pyradox.filetype.yml.parse_file(fullpath)
import hoi4
import os
import pyradox
import pyradox
terrains = pyradox.txt.parse_file(os.path.join(
pyradox.get_game_directory('HoI4'), 'common', 'terrain', '00_terrain.txt'),
verbose=False)['categories']
def compute_unit_stat_function(stat_key):
def compute_unit_stat(terrain_key, terrain):
if "units" not in terrain: return ""
return pyradox.wiki.colored_percent_string(terrain["units"][stat_key]
or 0.0)
return compute_unit_stat
columns = (
("Terrain", lambda k, v: "[[File:terrain %s.png]] %s" % (k, k.title())),
("Movement cost", "%(movement_cost)0.2f"),
("Attrition", lambda k, v: pyradox.wiki.colored_percent_string(
v["attrition"] or 0.0, color="red")),
#("Combat width", lambda k, v: pyradox.format.colored_percent_string(v["combat_width"] or 0.0)),
("Attack", compute_unit_stat_function("attack")),
("Enemy air superiority", lambda k, v: pyradox.wiki.colored_percent_string(
v["enemy_army_bonus_air_superiority_factor"] or 0.0)),
)
import os
import hoi4
import pyradox
game = 'HoI4'
def compute_country_tag_and_name(filename):
m = re.match('.*([A-Z]{3})\s*-\s*(.*)\.txt$', filename)
return m.group(1), m.group(2)
countries = {}
total = pyradox.Tree()
for filename, country in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'countries')):
tag, name = compute_country_tag_and_name(filename)
country['tag'] = tag
ruling_party = country['set_politics']['ruling_party'] or 'neutrality'
country['name'] = pyradox.yml.get_localisation('%s_%s' % (tag, ruling_party), game = 'HoI4')
countries[tag] = country
states = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'states'))
state_categories = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory(game), 'common', 'state_category'),
verbose=False, merge_levels = 1)
state_categories = state_categories['state_categories']
for state in states.values():
history = state['history']
tag = history['owner']
import _initpath
import os
import re
import collections
import pyradox
from PIL import Image
region_colors = pyradox.txt.parse_file(
os.path.join(pyradox.get_game_directory('EU4'), 'map', 'area.txt'))
province_map = pyradox.worldmap.ProvinceMap()
region_colors = pyradox.txt.parse_file(
os.path.join(pyradox.get_game_directory('EU4'), 'common', 'region_colors',
'00_region_colors.txt'))
regions = pyradox.txt.parse_file(
os.path.join(pyradox.get_game_directory('EU4'), 'map', 'region.txt'))
trade_good_events = pyradox.txt.parse_file(
os.path.join(pyradox.get_game_directory('EU4'), 'events',
'TradeGoods.txt'))
colormap = {}
textmap = {}
for region_index, (region_key, region_provinces) in enumerate(regions.items()):
if not trade_good_events.contains_value_walk(region_key):
continue # filter to regions appearing in trade goods events
color = tuple(region_colors.value_at(region_index))
textmap[tuple(region_provinces)] = pyradox.format.human_title(region_key)
for province_id in region_provinces:
'create_corps_commander': 'General',
'create_navy_leader': 'Admiral',
}
columns = (
('Country', '{{flag|%(country)s}}', None),
('Name', '%(name)s', None),
('Type', lambda k, v: commander_type_keys[k], None),
('Skill', '%(skill)d', None),
('Traits', list_commander_traits, None),
)
commanders = pyradox.Tree()
for filename, country in pyradox.txt.parse_dir(
os.path.join(pyradox.get_game_directory('HoI4'), 'history',
'countries')):
tag, _ = compute_country_tag_and_name(filename)
ruling_party = country['set_politics']['ruling_party']
country_name = pyradox.yml.get_localisation('%s_%s' % (tag, ruling_party),
game='HoI4')
for commander_type_key in commander_type_keys.keys():
for leader in country.find_all(commander_type_key):
leader['country'] = country_name
commanders.append(commander_type_key, leader)
out = open("out/military_commanders.txt", "w", encoding="utf-8")
out.write(
pyradox.table.make_table(commanders,
'wiki',
columns,
import re
import collections
import pyradox
from PIL import Image
start_date = pyradox.Date('1444.11.11')
# get trade goods
resource_images = pyradox.image.split_strip(Image.open('in/resources.png'))
trade_good_icons = {}
tree = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'common', 'tradegoods', '00_tradegoods.txt'))
for idx, trade_good in enumerate(tree.keys()):
trade_good_icons[trade_good] = resource_images[idx]
resource_images[idx].save('out/tradegoods/trade_good_%s.png' % trade_good)
colormap = {}
iconmap = {}
for filename, data in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('EU4'), 'history', 'provinces'), verbose=False):
m = re.match('\d+', filename)
province_id = int(m.group(0))
start_data = data.at_date(start_date)
# end_data = data.at_date(True)
if 'base_tax' in data:
if 'owner' in start_data:
colormap[province_id] = (191, 191, 191)
(15, 50) : lambda level: cost0_5(level * 2 + 1),
(30, 140) : lambda level: cost0_5(level * 4),
}
bonuses = {}
def eval_bonus(bonus_key, bonus_value):
if bonus_key in bonuses:
power_type, base_value, max_level, costs = bonuses[bonus_key]
cost_function = cost_functions[costs]
level = bonus_value / base_value
return power_type, 10 * level / max_level, cost_function(level), costs[0] + (level - 1) * (costs[1] - costs[0])
else:
return None
for file_name, file_data in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('EU4'), 'common', 'custom_ideas')):
for idea_set in file_data.values():
# start category
for idea, idea_data in idea_set.items():
if idea == 'category':
power_type = idea_data.lower()
continue
costs = [0, 5] # cost indexed by level (0-based)
max_level = 4
for key, value in idea_data.items():
if key in ('default', 'chance'):
continue
elif key == 'max_level':
max_level = value
import _initpath
import pyradox
import os
building_path = os.path.join(pyradox.get_game_directory('Stellaris'), 'common',
'buildings')
data = pyradox.txt.parse_merge(building_path, game='Stellaris')
for building_key, building in data.items():
if not isinstance(building, pyradox.Tree): continue
can_habitat = True
if 'potential' in building:
for planet in building['potential'].find_all('planet'):
for n in planet.find_all('not'):
for k, v in n.items():
if k == 'is_planet_class' and v == 'pc_habitat':
can_habitat = False
if can_habitat: print(building_key)
import math
import re
import collections
import pyradox
from PIL import Image
game = 'HoI4'
scale = 2.0
colormap_power = 1.0
# Load states.
states = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory(game),
'history', 'states'),
verbose=False)
province_map = pyradox.worldmap.ProvinceMap(game=game)
# provinces -> state id
groups = {}
colormap = {}
for state in states.values():
if 'resources' in state:
resources = sum(state['resources'].values())
k = []
for province_id in state.find_all('provinces'):
if not province_map.is_water_province(province_id):
next_monarch_name = heir['monarch_name']
cost = 0.0
if monarch is not None:
skill = sum(monarch[x] for x in ('adm', 'dip', 'mil'))
age = max(15, (date - monarch_birth) / 365)
print(skill, age)
cost += 2 * (skill - 6) * 30 / age
if heir is not None:
skill = sum(heir[x] for x in ('adm', 'dip', 'mil'))
age = (date - heir_birth) / 365
cost += 2 * (skill - 6) * 30 / (age + 15)
return cost
governments = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory('EU4'), 'common', 'governments'))
def government_cost(country, date = pyradox.Date('1444.11.11')):
country = country.at_date(date)
if 'government' not in country: return 0.0
government = governments[country['government']]
if 'nation_designer_cost' in government:
return government['nation_designer_cost']
else:
return 0.0
continents = {}
for continent, provinces_id_s in pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'map', 'continent.txt')).items():
for province_id in provinces_id_s:
if province_id in continents:
print('Duplicate continent for province %d' % province_id)
import pyradox
import province_costs
sources = ['EU4', 'text', 'nw2', 'res_publica', "aow"]
def localized(s):
return pyradox.yml.get_localisation(s) or pyradox.format.human_title(s)
culture_groups = {}
culture_tree = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'common', 'cultures', '00_cultures.txt'))
for group_name, group_data in culture_tree.items():
for culture in group_data:
culture_groups[culture] = group_name
culture_data = {}
culture_group_data = {}
for filename, data in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('EU4'), 'history', 'provinces'), verbose=False):
data = data.at_date(pyradox.Date('1444.11.11'))
if 'culture' not in data:
if 'base_tax' in data:
print('No culture defined in %s.' % filename)
continue
if 'owner' not in data:
import _initpath
import os
import re
import collections
import pyradox
from PIL import Image
region_colors = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'map', 'area.txt'))
province_map = pyradox.worldmap.ProvinceMap()
region_colors = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'common', 'region_colors', '00_region_colors.txt'))
regions = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'map', 'region.txt'))
trade_good_events = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'events', 'TradeGoods.txt'))
colormap = {}
textmap = {}
for region_index, (region_key, region_provinces) in enumerate(regions.items()):
if not trade_good_events.contains_value_walk(region_key): continue # filter to regions appearing in trade goods events
color = tuple(region_colors.value_at(region_index))
textmap[tuple(region_provinces)] = pyradox.format.human_title(region_key)
for province_id in region_provinces:
colormap[province_id] = color
out = province_map.generate_image(colormap, edge_color = (255, 255, 255))
province_map.overlay_text(out, textmap, fontsize = 16)
import pyradox
def get_stability_likely(conditions):
result = [0 for x in range(7)]
for stability in conditions.find_all("stability"):
result[stability] = 1
for not_condition in conditions.find_all("NOT"):
for stability in not_condition.find_all("stability"):
result[stability] = -1
return result
events_tree = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'events', 'Republics.txt'))
allow_events = list(list([] for x in range(3)) for x in range(7))
likely_events = list(list([] for x in range(3)) for x in range(7))
for event in events_tree.find_all("country_event"):
event_name = pyradox.yml.get_localisation(event["title"])
if "trigger" in event:
allow = get_stability_likely(event["trigger"])
for i, x in enumerate(allow):
if event_name not in allow_events[i][x]:
allow_events[i][x].append(event_name)
if "mean_time_to_happen" in event:
likelies = [0] * 7
for modifier in event["mean_time_to_happen"].find_all("modifier"):
import hoi4
import re
import os
import pyradox
def compute_country_tag_and_name(filename):
m = re.match('.*([A-Z]{3})\s*-\s*(.*)\.txt$', filename)
return m.group(1), m.group(2)
economics = pyradox.txt.parse_file(
os.path.join(pyradox.get_game_directory('HoI4'), 'common', 'ideas',
'_economic.txt'))['ideas']
result = pyradox.Tree()
for filename, country in pyradox.txt.parse_dir(
os.path.join(pyradox.get_game_directory('HoI4'), 'history',
'countries')):
country = country.at_time('1936.1.1')
tag, name = compute_country_tag_and_name(filename)
country['tag'] = tag
ruling_party = country['set_politics']['ruling_party']
country['name'] = pyradox.yml.get_localisation('%s_%s' %
(tag, ruling_party),
game='HoI4')
result[tag] = country
if 'add_ideas' in country:
import _initpath
import os
import re
import collections
import pyradox
import load.province
vanilla_provinces = load.province.get_provinces(basedir = pyradox.get_game_directory('HoI3_vanilla'))
tfh_provinces = load.province.get_provinces(basedir = pyradox.get_game_directory('HoI3'))
province_map = pyradox.worldmap.ProvinceMap(pyradox.get_game_directory('HoI3'), flip_y = True)
province_contents = {
'infra' : (1, 10, 1),
'industry' : (1, 10, 1),
'leadership' : (0.0, 3.0, 0.5),
'manpower' : (0.0, 20.0, 1.0),
'energy' : (0.0, 150.0, 10.0),
'metal' : (0.0, 100.0, 10.0),
'rare_materials' : (0.0, 30.0, 2.5),
'crude_oil' : (0.0, 160.0, 10.0),
'air_base' : (1, 10, 1),
'naval_base' : (1, 10, 1),
'anti_air' : (1, 10, 1),
'points' : (0, 30, 5),
}
def print_legend(min_val, max_val, step = 1):
result = ''
import _initpath
import os
import re
import collections
import pyradox
tree = pyradox.parse_file(
os.path.join(pyradox.get_game_directory('EU4'), 'common', 'wargoal_types',
'00_wargoal_types.txt'))
def left_columns(wargoal, data, side=None):
result = '|-\n'
if side is None:
result += '| %s\n' % pyradox.format.human_string(wargoal, True)
else:
result += '| %s (%s)\n' % (pyradox.format.human_string(wargoal,
True), side)
result += '| %s\n' % pyradox.format.human_string(data["type"], True)
if 'allow_leader_change' in data:
result += '| {{Icon|yes}}\n'
else:
result += '| {{Icon|no}}\n'
return result
def right_columns(wargoal, po_data):
result = ''
min_native_size = 0
max_native_size = 9000
gamma = 1.0
def colormap_min_max(x, min_val, max_val):
return pyradox.image.colormap_blue_red(
pow(max(x - min_val, 0) / (max_val - min_val), gamma))
native_size_colormap = {}
native_size_textmap = {}
for filename, data in pyradox.txt.parse_dir(os.path.join(
pyradox.get_game_directory('EU4'), 'history', 'provinces'),
verbose=False):
m = re.match('\d+', filename)
province_id = int(m.group(0))
if 'native_size' in data:
native_size_colormap[province_id] = colormap_min_max(
data['native_size'] * 100, min_native_size, max_native_size)
native_size_textmap[province_id] = '%d' % (data['native_size'] * 100)
elif 'base_tax' in data:
native_size_colormap[province_id] = (127, 127, 127)
province_map = pyradox.worldmap.ProvinceMap()
image = province_map.generate_image(native_size_colormap)
province_map.overlay_text(image,
native_size_textmap,
def __init__(self, game, flip_y=False):
"""Creates a province map using the base game directory specified, defaulting to the one in pyradox.config."""
self.game = game
basedir = pyradox.get_game_directory(game)
provinces_bmp = os.path.join(basedir, 'game', 'map_data',
'provinces.png')
definition_csv = os.path.join(basedir, 'game', 'map_data',
'definition.csv')
default_map = os.path.join(basedir, 'game', 'map_data', 'default.map')
self.province_image = Image.open(provinces_bmp)
if flip_y:
self.province_image = self.province_image.transpose(
Image.FLIP_TOP_BOTTOM)
with open(definition_csv) as definition_file:
csv_reader = csv.reader(definition_file, delimiter=';')
self.province_color_by_id = {}
self.province_id_by_color = {}
self.water_provinces = set()
self.impassable_provinces = set()
self.river_provinces = set()
self.lake_provinces = set()
self.impassable_sea_provinces = set()
self._adjacency = {} # lazy evaluation
default_map_data = self.parse_default_file()
for water_province in default_map_data.water_provinces:
self.water_provinces.add(water_province)
for impassable_province in default_map_data.impassable_provinces:
self.impassable_provinces.add(impassable_province)
for river_province in default_map_data.river_provinces:
self.river_provinces.add(river_province)
for impassable_province in default_map_data.lake_provinces:
self.lake_provinces.add(impassable_province)
for impassable_province in default_map_data.impassable_sea_provinces:
self.impassable_sea_provinces.add(impassable_province)
#water_keys = ('sea_starts', 'lakes')
#default_tree = pyradox.parse_file(default_map, verbose=False)
#max_province = default_tree['max_provinces']
#for key in water_keys:
# for province_id in default_tree.find_all(key):
# self.water_provinces.add(province_id)
province_count = 0
for row in csv_reader:
try:
province_id = int(row[0])
province_color = (int(row[1]), int(row[2]), int(row[3]))
if row[4] in ("sea", "lake"):
self.water_provinces.add(province_id) # HoI4
self.province_color_by_id[province_id] = province_color
self.province_id_by_color[province_color] = province_id
province_count += 1
except ValueError:
warnings.warn(
'Could not parse province definition from row "%s" of %s.'
% (str(row), definition_csv))
pass
print("Read %d provinces from %s." %
(province_count, definition_csv))
self.positions = {}
self.positions['centroid'] = {
province_id: (0.0, 0.0)
for province_id in self.province_color_by_id.keys()
}
self.province_sizes = {
province_id: 0
for province_id in self.province_color_by_id.keys()
}
# compute province sizes and centroids (assume no provinces wrap around)
for index, pixel in enumerate(self.province_image.getdata()):
x = index % self.province_image.size[0]
y = index // self.province_image.size[0]
province_id = self.province_id_by_color[pixel]
self.province_sizes[province_id] += 1
prev_x, prev_y = self.positions['centroid'][province_id]
self.positions['centroid'][province_id] = (prev_x + x, prev_y + y)
for province_id in self.positions['centroid'].keys():
size = self.province_sizes[province_id]
if size > 0:
prev_x, prev_y = self.positions['centroid'][province_id]
self.positions['centroid'][province_id] = (prev_x / size,
prev_y / size)
else:
warnings.warn('Province %d has size 0.' % province_id)
print('Computed province centroids.')
max_y = self.province_image.size[1] # use image coords
if 'HoI4' in game:
building_headings = [
'state_id', 'type', 'x', 'x_offset', 'y', 'y_offset',
'sea_province_id'
]
buildings = pyradox.csv.parse_file(['map', 'buildings.txt'],
game=game,
headings=building_headings)
for _, row in buildings.items():
building_type = row['type']
x, y = int(row['x']), max_y - int(row['y'])
province_id = self.province_at_coordinates(x, y)
if building_type not in self.positions:
self.positions[building_type] = {}
self.positions[building_type][province_id] = (row['x'],
max_y - row['y'])
"""
unitstack_headings = ['province_id', 'type', 'x', 'x_offset', 'y', 'y_offset', 'z']
self.positions['unitstacks'] = {}
unitstacks = pyradox.csv.parse_file(['map', 'unitstacks.txt'], game = game, headings = unitstack_headings)
for province_id, row in unitstacks.items():
self.positions['unitstacks'][province_id] = (row['x'], max_y - row['y'])
"""
print('Read province positions.')
"""
bonuses = {}
def eval_bonus(bonus_key, bonus_value):
if bonus_key in bonuses:
power_type, base_value, max_level, costs = bonuses[bonus_key]
cost_function = cost_functions[costs]
level = bonus_value / base_value
return power_type, 10 * level / max_level, cost_function(
level), costs[0] + (level - 1) * (costs[1] - costs[0])
else:
return None
for file_name, file_data in pyradox.txt.parse_dir(
os.path.join(pyradox.get_game_directory('EU4'), 'common',
'custom_ideas')):
for idea_set in file_data.values():
# start category
for idea, idea_data in idea_set.items():
if idea == 'category':
power_type = idea_data.lower()
continue
costs = [0, 5] # cost indexed by level (0-based)
max_level = 4
for key, value in idea_data.items():
if key in ('default', 'chance'):
continue
elif key == 'max_level':
import os
import hoi4
import pyradox
game = 'HoI4'
def compute_country_tag_and_name(filename):
m = re.match('.*([A-Z]{3})\s*-\s*(.*)\.txt$', filename)
return m.group(1), m.group(2)
countries = {}
total = pyradox.Tree()
for filename, country in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'countries')):
tag, name = compute_country_tag_and_name(filename)
country['tag'] = tag
ruling_party = country['set_politics']['ruling_party'] or 'neutrality'
country['name'] = pyradox.yml.get_localisation('%s_%s' % (tag, ruling_party), game = 'HoI4')
countries[tag] = country
states = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'states'))
state_categories = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory(game), 'common', 'state_category'),
verbose=False, merge_levels = 1)
state_categories = state_categories['state_categories']
for state in states.values():
history = state['history']
tag = history['owner']
import pyradox
import time
def parse_walk(dirname, verbose=False):
"""Given a directory, recursively iterate over the content of the .txt files in that directory as Trees"""
skip = '\\\\(map|wiki|interface|pdx_launcher|previewer_assets)\\\\'
start_time = time.clock()
file_count = 0
do_txt = True
do_yml = True
dirname = os.path.join(pyradox.get_game_directory('HoI4'))
for root, dirs, files in os.walk(dirname):
if root == dirname: continue
for filename in files:
fullpath = os.path.join(root, filename)
if re.search(skip, fullpath): continue
_, ext = os.path.splitext(fullpath)
if do_txt and ext == '.txt':
try:
pyradox.parse_file(fullpath)
file_count += 1
except:
print(sys.exc_info())
elif do_yml and ext == '.yml':
try:
pyradox.filetype.yml.parse_file(fullpath)
import hoi4
import os
import re
import collections
import pyradox
from PIL import Image
# Load states.
states = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory('HoI4'), 'history', 'states'), verbose=False)
# provinces -> state id
groups = {}
for state in states.values():
k = tuple(province_id for province_id in state.find_all('provinces'))
groups[k] = str(state['id'])
# Load the province map using the default location set in pyradox.
province_map = pyradox.worldmap.ProvinceMap(game = 'HoI4')
out = province_map.generate_image({}, default_land_color=(255, 255, 255), edge_groups = groups.keys())
pyradox.image.save_using_palette(out, 'out/blank_state_map.png')
import hoi4
import os
import pyradox
import pyradox
terrains = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('HoI4'), 'common', 'terrain', '00_terrain.txt'), verbose=False)['categories']
def compute_unit_stat_function(stat_key):
def compute_unit_stat(terrain_key, terrain):
if "units" not in terrain: return ""
return pyradox.wiki.colored_percent_string(terrain["units"][stat_key] or 0.0)
return compute_unit_stat
columns = (
("Terrain", lambda k, v: "[[File:terrain %s.png]] %s" % (k, k.title())),
("Movement cost", "%(movement_cost)0.2f"),
("Attrition", lambda k, v: pyradox.wiki.colored_percent_string(v["attrition"] or 0.0, color = "red")),
#("Combat width", lambda k, v: pyradox.format.colored_percent_string(v["combat_width"] or 0.0)),
("Attack", compute_unit_stat_function("attack")),
("Enemy air superiority", lambda k, v: pyradox.wiki.colored_percent_string(v["enemy_army_bonus_air_superiority_factor"] or 0.0)),
)
file = open("out/terrain.txt", "w")
file.write(pyradox.table.make_table(terrains, 'wiki', columns, lambda k, v: "sound_type" in v and not v["is_water"]))
file.close()
import _initpath
import pyradox
import os
building_path = os.path.join(
pyradox.get_game_directory('Stellaris'),
'common',
'buildings')
data = pyradox.txt.parse_merge(building_path, game = 'Stellaris')
for building_key, building in data.items():
if not isinstance(building, pyradox.Tree): continue
can_habitat = True
if 'potential' in building:
for planet in building['potential'].find_all('planet'):
for n in planet.find_all('not'):
for k, v in n.items():
if k == 'is_planet_class' and v == 'pc_habitat':
can_habitat = False
if can_habitat: print(building_key)
def compute_country_tag_and_name(filename):
m = re.match('.*([A-Z]{3})\s*-\s*(.*)\.txt$', filename)
return m.group(1), m.group(2)
countries = {}
for filename, country in pyradox.txt.parse_dir(('history', 'countries'), game = game):
country = country.at_time(date)
tag, name = compute_country_tag_and_name(filename)
country['tag'] = tag
ruling_party = country['set_politics']['ruling_party'] or 'neutrality'
country['name'] = pyradox.yml.get_localisation('%s_%s' % (tag, ruling_party), game = game)
countries[tag] = country
states = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory(game), 'history', 'states'))
state_categories = pyradox.txt.parse_merge(os.path.join(pyradox.get_game_directory(game), 'common', 'state_category'),
verbose=False, merge_levels = 1)
state_categories = state_categories['state_categories']
for state in states.values():
history = state['history'].at_time(date, merge_levels = -1)
# if state['id'] == 50: print('state50', history)
state['owner'] = history['owner']
state['owner_name'] = countries[history['owner']]['name']
state['human_name'] = pyradox.yml.get_localisation(state['name'], game = game)
country = countries[tag]
country['states'] = (country['states'] or 0) + 1
localisation_sources = ['EU4', 'text', 'modifers']
default_max_level = 4
result = ''
result += '{|class = "wikitable sortable mw-collapsible mw-collapsed"\n'
result += '! rowspan = "2" | Bonus !! rowspan = "2" | Per level !! rowspan = "2" | Category !! colspan = "%d" | Cost \n' % default_max_level
result += '|-\n'
for i in range(default_max_level):
result += '! %d !' % (i + 1)
result = result[:-1]
result += '\n'
for file_name, file_data in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('EU4'), 'common', 'custom_ideas')):
for idea_set in file_data.values():
# start category
for idea, idea_data in idea_set.items():
if idea == 'category':
power_type = idea_data.lower()
continue
# compile idea stats
max_level = default_max_level
costs = [0, 5, 15, 30] # cost indexed by level (0-based)
for key, value in idea_data.items():
if key in ('default', 'chance'):
continue
import _initpath
import os
import re
import collections
import pyradox
import pyradox
start_date = pyradox.Date('1444.11.11')
counts = pyradox.Tree() # province counts
# parse all files in a directory, producing instances of pyradox.Tree
for filename, data in pyradox.txt.parse_dir(os.path.join(pyradox.get_game_directory('EU4'), 'history', 'provinces')):
# pyradox.Tree has many dict methods, such as .keys()
if 'base_tax' not in data.keys(): continue
trade_good = 'unknown'
for curr_good in data.find_walk('trade_goods'):
if curr_good != 'unknown':
trade_good = curr_good
if trade_good not in counts: counts[trade_good] = 1
else: counts[trade_good] += 1
print([(key, counts[key]) for key in counts.keys()])
import _initpath
import os
import pyradox
colormap = {}
tree = pyradox.txt.parse_file(os.path.join(pyradox.get_game_directory('EU4'), 'decisions', 'Muslim.txt'))
unify_requirements = tree['country_decisions']['unify_islam']['allow']
for province_id in unify_requirements.find_all('owns_or_vassal_of'):
colormap[province_id] = (0, 127, 0)
province_map = pyradox.worldmap.ProvinceMap()
out = province_map.generate_image(colormap)
out.save('out/unify_islam_map.png')
