""" Various helpers for use by the wmlunits tool. """ import sys, os, re, glob, shutil, copy, urllib2, subprocess import wesnoth.wmlparser2 as wmlparser2 import wesnoth.wmltools as wmltools def get_datadir(wesnoth_exe): p = subprocess.Popen([wesnoth_exe, "--path"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) out, err = p.communicate() return out.strip() def get_userdir(wesnoth_exe): p = subprocess.Popen([wesnoth_exe, "--config-path"], stdout = subprocess.PIPE, stderr = subprocess.PIPE) out, err = p.communicate() return out.strip() class Image: def __init__(self, id_name, ipath, bases, no_tc): self.id_name = id_name self.ipath = ipath # none if it was not found self.bases = bases self.no_tc = no_tc self.addons = set() class ImageCollector: """ A class to collect all the images which need to be copied to the HTML output folder. """ def __init__(self, wesnoth_exe, userdir, datadir): self.images_by_addon_name = {} self.images_by_ipath = {} self.binary_paths_per_addon = {} self.datadir = datadir self.userdir = userdir if not self.datadir: self.datadir = get_datadir(wesnoth_exe) if not self.userdir: self.userdir = get_userdir(wesnoth_exe) def add_binary_paths_from_WML(self, addon, WML): for binpath in WML.get_all(tag = "binary_path"): path = binpath.get_text_val("path") if addon not in self.binary_paths_per_addon: self.binary_paths_per_addon[addon] = [] self.binary_paths_per_addon[addon].append(path) def _find_image(self, addon, name): tilde = name.find("~") if tilde >= 0: name = name[:tilde] bases = [os.path.join(self.datadir, "data/core/images")] binpaths = self.binary_paths_per_addon.get(addon, [])[:] binpaths.reverse() for x in binpaths: for idir in ["images", "images/units"]: bases.append(os.path.join(self.datadir, x, idir)) bases.append(os.path.join(self.userdir, x, idir)) bases = [os.path.join("%s" % base, name) for base in bases] for ipath in bases: if os.path.exists(ipath): return ipath, bases return None, bases def add_image_check(self, addon, name, no_tc = False): if (addon, name) in self.images_by_addon_name: image = self.images_by_addon_name[(addon, name)] if addon not in image.addons: image.addons.add(addon) return image ipath, bases = self._find_image(addon, name) if ipath in self.images_by_ipath: image = self.images_by_ipath[ipath] if addon not in image.addons: image.addons.add(addon) return image def make_name(x): x = x.strip("./ ") d = options.config_dir.strip("./ ") if x.startswith(d): x = x[len(d):] d = options.data_dir.strip("./ ") if x.startswith(d): x = x[len(d):] x = x.strip("./ ") if x.startswith("data"): x = x[len("data"):] x = x.strip("./ ") y = "" for c in x: if c == "/": c = "$" elif not c.isalnum() and c not in ".+-()[]{}": c = "_" y += c return y if ipath: id_name = make_name(ipath) else: id_name = make_name(addon + "/" + name) image = Image(id_name, ipath, bases, no_tc) image.addons.add(addon) self.images_by_addon_name[(addon, name)] = image if ipath: self.images_by_ipath[ipath] = image return image def add_image(self, addon, path, no_tc = False): image = self.add_image_check(addon, path, no_tc) return image.id_name def copy_and_color_images(self, target_path): for image in self.images_by_ipath.values(): opath = os.path.join(target_path, "pics", image.id_name) try: os.makedirs(os.path.dirname(opath)) except OSError: pass no_tc = image.no_tc ipath = os.path.normpath(image.ipath) cdir = os.path.normpath(options.config_dir + "/data/add-ons") if ipath.startswith(cdir): ipath = os.path.join(options.addons, ipath[len(cdir):].lstrip("/")) if ipath and os.path.exists(ipath): if no_tc: shutil.copy2(ipath, opath) else: # We assume TeamColorizer is in the same directory as the # helpers.py currently executing. command = os.path.join(os.path.dirname(__file__), "TeamColorizer") p = subprocess.Popen([command, ipath, opath]) p.wait() else: sys.stderr.write( "Warning: Required image %s does not exist (referenced by %s).\n" % ( image.id_name, ", ".join(image.addons))) if options.verbose: if image.bases: sys.stderr.write("Warning: Looked at the following locations:\n") sys.stderr.write("\n".join(image.bases) + "\n") else: sys.stderr.write("nowhere\n") blah = 1 class WesnothList: """ Lists various Wesnoth stuff like units, campaigns, terrains, factions... """ def __init__(self, wesnoth_exe, config_dir, data_dir, transdir): self.unit_lookup = {} self.race_lookup = {} self.terrain_lookup = {} self.movetype_lookup = {} self.era_lookup = {} self.campaign_lookup = {} self.parser = wmlparser2.Parser(wesnoth_exe, config_dir, data_dir, no_preprocess = False) def add_terrains(self): """ We need those for movement costs and defenses. """ self.parser.parse_text("{core/terrain.cfg}\n") n = 0 for terrain in self.parser.get_all(tag = "terrain_type"): tstring = terrain.get_text_val("string") self.terrain_lookup[tstring] = terrain n += 1 return n def add_languages(self, languages): """ Returns a dictionary mapping isocodes to languages. """ self.languages_found = {} parser = wmlparser2.Parser(options.wesnoth, options.config_dir, options.data_dir, no_preprocess = False) parser.parse_text("{languages}") for locale in parser.get_all(tag="locale"): isocode = locale.get_text_val("locale") name = locale.get_text_val("name") if isocode == "ang_GB": continue self.languages_found[isocode] = name def add_era(self, era): """ For an era, list all factions and units in it. """ eid = era.get_text_val("id") if not eid: return self.era_lookup[eid] = era era.faction_lookup = {} for multiplayer_side in era.get_all(tag = "multiplayer_side"): fid = multiplayer_side.get_text_val("id") if fid == "Random": continue era.faction_lookup[fid] = multiplayer_side recruit = multiplayer_side.get_text_val("recruit", "").strip() leader = multiplayer_side.get_text_val("leader", "").strip() units = recruit.split(",") leaders = leader.split(",") multiplayer_side.units = {} multiplayer_side.is_leader = {} for u in units: uid = u.strip() if uid: multiplayer_side.units[uid] = True for u in leaders: uid = u.strip() if uid: multiplayer_side.units[uid] = True multiplayer_side.is_leader[uid] = True return eid def add_binary_paths(self, addon, image_collector): image_collector.add_binary_paths_from_WML(addon, self.parser.root) def add_campaign(self, campaign): name = campaign.get_text_val("id") if not name: global blah name = "noid%d" % blah blah += 1 self.campaign_lookup[name] = campaign return name def add_mainline_eras(self): """ Find all mainline eras. """ self.parser.parse_text("{multiplayer/eras.cfg}") n = 0 for era in self.parser.get_all(tag = "era"): self.add_era(era) n += 1 return n def add_units(self, campaign): """ We assume each unit, in mainline and all addons, has one unique id. So we reference them everywhere by this id, and here can add them all to one big collection. """ addunits = self.parser.get_all(tag = "units") addunits += self.parser.get_all(tag = "+units") if not addunits: return 0 def getall(oftype): r = [] r = [] for units in addunits: r += units.get_all(tag = oftype) return r # Find all unit types. newunits = getall("unit_type") + getall("unit") for unit in newunits: uid = unit.get_text_val("id") unit.id = uid if unit.get_text_val("do_not_list", "no") != "no" or\ unit.get_text_val("hide_help", "no") not in ["no", "false"]: unit.hidden = True else: unit.hidden = False if uid in self.unit_lookup: unit = self.unit_lookup[uid] # TODO: We might want to compare the two units # with the same id and if one is different try # to do something clever like rename it... else: self.unit_lookup[uid] = unit if not hasattr(unit, "campaigns"): unit.campaigns = [] unit.campaigns.append(campaign) # Find all races. newraces = getall("race") for race in newraces: rid = race.get_text_val("id") if rid == None: rid = race.get_text_val("name") self.race_lookup[rid] = race # Find all movetypes. newmovetypes = getall("movetype") for movetype in newmovetypes: mtname = movetype.get_text_val("name") self.movetype_lookup[mtname] = movetype # Store race/movetype/faction of each unit for easier access later. for unit in newunits: uid = unit.get_text_val("id") race = self.get_unit_value(unit, "race") try: unit.race = self.race_lookup[race] unit.rid = unit.race.get_text_val("id", "none") except KeyError: unit.race = None unit.rid = "none" error_message("Warning: No race \"%s\" found (%s).\n" % ( race, unit.get_text_val("id"))) movetype = self.get_unit_value(unit, "movement_type") try: unit.movetype = self.movetype_lookup[movetype] except KeyError: unit.movetype = None unit.advance = [] advanceto = unit.get_text_val("advances_to") # Add backwards compatibility for 1.4 if not advanceto: advanceto = unit.get_text_val("advanceto") if advanceto and advanceto != "null": for advance in advanceto.split(","): auid = advance.strip() if auid: unit.advance.append(auid) # level try: level = int(self.get_unit_value(unit, "level")) except TypeError: level = 0 except ValueError: level = 0 if level < 0: level = 0 unit.level = level return len(newunits) def check_units(self): """ Once all units have been added, do some checking. """ # handle advancefrom tags for uid, unit in self.unit_lookup.items(): for advancefrom in unit.get_all(tag = "advancefrom"): fromid = advancefrom.get_text_val("unit") if fromid: try: fromunit = self.unit_lookup[fromid] except KeyError: error_message( "Error: Unit '%s' references non-existant [advancefrom] unit '%s'" % ( uid, fromid)) continue if uid not in fromunit.advance: fromunit.advance.append(uid) def find_unit_factions(self): for unit in self.unit_lookup.values(): unit.factions = [] unit.eras = [] for eid, era in self.era_lookup.items(): for fid, multiplayer_side in era.faction_lookup.items(): for uid in multiplayer_side.units: try: unit = self.unit_lookup[uid] except KeyError: error_message( ("Error: Era '%s' faction '%s' references " + "non-existant unit id '%s'!\n") % ( eid, fid, str(uid))) continue if not eid in unit.eras: unit.eras.append(eid) unit.factions.append((eid, fid)) # as a special case, add units from this addon but with no faction for unit in self.unit_lookup.values(): if unit.campaigns[0] == self.cid: if not unit.factions: if not eid in unit.eras: unit.eras.append(eid) unit.factions.append((eid, None)) def get_base_unit(self, unit): b = unit.get_all(tag = "base_unit") if b: b = b[0] buid = b.get_text_val("id") try: baseunit = self.unit_lookup[buid] except KeyError: error_message( "Warning: No baseunit \"%s\" for \"%s\".\n" % ( buid, unit.get_text_val("id"))) return None return baseunit return None def get_unit_value(self, unit, attribute, default = None, translation = None): value = unit.get_text_val(attribute, None, translation) if value == None: baseunit = self.get_base_unit(unit) if baseunit: return self.get_unit_value(baseunit, attribute, default, translation) return default return value class UnitForest: """ Contains the forest of unit advancement trees. """ def __init__(self): self.trees = {} self.lookup = {} def add_node(self, un): """ Add a new unit to the forest. """ self.lookup[un.id] = un def create_network(self): """ Assuming that each node which has been added to the tree only has a valid list of children in unit.child_ids, also fill in unit.parent_ids and update the unit.children shortcut. """ # Complete the network for uid, u in self.lookup.items(): for cid in u.child_ids: c = self.lookup.get(cid, None) if not c: continue u.children.append(c) if not uid in c.parent_ids: c.parent_ids.append(uid) # Put all roots into the forest for uid, u in self.lookup.items(): if not u.parent_ids: self.trees[uid] = u # Sanity check because some argGRRxxx addons have units who advance to # themselves. def recurse(u, already): already2 = already.copy() for c in u.children[:]: already2[c.id] = True if c.id in already: error_message( ("Warning: Unit %s advances to unit %s in a loop.\n" % (u.id, c.id)) + (" Removing advancement %s.\n" % c.id)) u.children.remove(c) for c in u.children: recurse(c, already2) for u in self.trees.values(): already = {u.id : True} recurse(u, already) def update(self): self.create_network() self.breadth = sum([x.update_breadth() for x in self.trees.values()]) return self.breadth def get_children(self, uid): un = self.lookup[uid] return un.child_ids def get_parents(self, uid): un = self.lookup[uid] return un.parent_ids class UnitNode: """ A node in the advancement trees forest. """ def __init__(self, unit): self.unit = unit self.children = [] self.id = unit.get_text_val("id") self.child_ids = [] self.parent_ids = [] self.child_ids.extend(unit.advance) def update_breadth(self): if not self.children: self.breadth = 1 else: self.breadth = sum([x.update_breadth() for x in self.children]) return self.breadth class GroupNode: def __init__(self, data): self.data = data