pywargame 0.3.1__py3-none-any.whl

pywargame/zuntzu/gamebox.py

@@ -0,0 +1,154 @@
+## BEGIN_IMPORTS
+from base import DomInspect
+from map import ZTMap
+from piece import ZTPiece
+from countersheet import ZTCounterSheet
+from dicehand import ZTDiceHand
+from common import VerboseGuard
+from scenario import ZTScenario
+## END_IMPORTS
+
+# --------------------------------------------------------------------
+class ZTGameBox(DomInspect):
+    
+    def __init__(self,file):
+        from zipfile import ZipFile
+        from xml.dom.minidom import parse
+
+        with VerboseGuard('Reading gamebox') as v:
+            self._zip = ZipFile(file,'r')
+            
+            with self._zip.open('game-box.xml','r') as xml:
+                self._gamebox =parse(xml)
+                
+                self._root    = self._gamebox.firstChild
+                self._name    = self._get_attr(self._root,'name')
+                self._desc    = self._get_attr(self._root,'description')
+                self._copy    = self._get_attr(self._root,'copyright')
+                self._start   = self._get_attr(self._root,'startup-scenario')
+                self._icon    = self._get_attr(self._root,'icon',None)
+                self._splash  = None
+                self._sheets_map = {}
+
+                if not self._icon and 'icon.bmp' in self._zip.namelist():
+                    self._icon = 'icon.bmp'
+                v(f'Icon is {self._icon}')
+                    
+                if self._icon:
+                    self._splash = self._read_image(self._zip, self._icon)
+                    v(f'Got splash screen {self._icon}: {self._splash}')
+            
+                self._dice_hands = [
+                    self.parse_dice_hand(dh)
+                    for dh in self._root.getElementsByTagName('dice-hand')]
+                # IF no dice was defined add a 1d6
+                if len(self._dice_hands) <= 0:
+                    self._dice_hands = [ ZTDiceHand(None) ]
+
+                self._maps = [
+                    self.parse_map(mp)
+                    for mp in self._root.getElementsByTagName('map')]
+
+                self._scenarios = [
+                    self.parse_scenario(fn)
+                    for fn in self._zip.namelist() if fn.endswith('.zts')]
+
+                # counter-sheet or terrain-sheet 
+                self._counter_sheets = [
+                    self.parse_counter_sheet(sh)
+                    for sh in self._find_children(self._root,
+                                                  'counter-sheet',
+                                                  'terrain-sheet')]
+
+                self._pieces = sum([c._piece for c in self._counter_sheets],[])
+                self._cards  = sum([c._card for  c in self._counter_sheets],[])
+                self.map_pieces()
+        
+    def parse_dice_hand(self,elem):
+        return ZTDiceHand(elem)
+
+    def parse_map(self,elem):
+        m = ZTMap(elem)
+        m.read_image(self._zip)
+        # self._master[m._name] = m
+        return m
+
+    def parse_counter_sheet(self,elem):
+        s = ZTCounterSheet(elem)
+        s.read_image(self._zip)
+        s.make_pieces()
+        self._sheets_map[s._name] = s
+        return s
+
+    def parse_scenario(self,fn):
+        with self._zip.open(fn,'r') as inp:
+            return ZTScenario(inp)
+
+    def write_image(self,dir,name,image):
+        if image is None:
+            return
+        
+        fn  = dir / f'{name}.{image.format.lower()}'
+        print(f'Writing {fn}')
+        image.save(filename=fn)
+
+    def map_pieces(self):
+        with VerboseGuard(f'Mapping pieces to ID and back'):
+            # Cards and pieces are intermingled
+            tmp = sum([c._piece+c._card for c in self._counter_sheets],[])
+            self._piece_map = {
+                i: p for i,p in enumerate(tmp) }
+            self._piece_id = {
+                v: k for k,v in self._piece_map.items()}
+        
+        
+    def write_images(self):
+        from pathlib import Path
+
+        dir = Path('images')
+        dir.mkdir(0o755,parents=True,exist_ok=True)
+
+        for m in self._maps:
+            if not m._image:
+                print(f'Missing image for map {m._name}')
+                continue
+
+            self.write_image(dir,m._name,m._image._image)
+            
+        for i,p in enumerate(self._pieces):
+            for img,nam in zip([p._front,p._back],
+                           ['front','back']):
+
+                self.write_image(dir,f'{i:04d}_{nam}',img)
+
+        for i,p in enumerate(self._cards):
+            for img,nam in zip([p._front,p._back],
+                           ['front','back']):
+
+                self.write_image(dir,f'c{i:04d}_{nam}',img)
+                
+        for s in self._counter_sheets:
+            name = s._name
+            for fac,nam in zip([s._front,s._back],
+                               ['front','back']):
+                if not fac:
+                    continue
+
+                self.write_image(dir,f'{name}_{nam}',fac._image)
+        
+
+    def __str__(self):
+        return (f'{self._name}'+'\n'+
+                f' Description: {self._desc}'+'\n'+
+                f' Copyright:   {self._copy}'+'\n'+
+                f' Start:       {self._start}'+'\n'+
+                f' Icon:        {self._icon}'+
+                ('\n' if len(self._dice_hands)>0 else '')+
+                '\n'.join([str(d) for d in self._dice_hands])+
+                ('\n' if len(self._maps)>0 else '')+
+                '\n'.join([str(m) for m in self._maps])+
+                ('\n' if len(self._counter_sheets)>0 else '')+
+                '\n'.join([str(s) for s in self._counter_sheets]))
+#
+# EOF
+#

pywargame/zuntzu/map.py

@@ -0,0 +1,36 @@
+## BEGIN_IMPORTS
+from base import DomInspect, ZTImage
+from common import VerboseGuard
+## END_IMPORTS
+
+# --------------------------------------------------------------------
+class ZTMap(DomInspect):
+    def __init__(self,elem):
+        with VerboseGuard(f'Got a map'):
+            self._name  = self._get_attr(elem,'name')
+            self._image = ZTImage(elem)
+
+    def read_image(self,zf):
+        with VerboseGuard(f'Reading map ({self._name}) image') as v:
+            self._image.read_image(zf)
+            sc = ZTImage.target_dpi / self._image._reso
+            v(f'Scale by {sc}={ZTImage.target_dpi}/{self._image._reso} '
+              f'from {self._image._image.width}x{self._image._image.height}')
+            self._image._image.resize(int(sc*self._image._image.width),
+                                      int(sc*self._image._image.height))
+            v(f'Scaled by {sc} to {self._image._image.width}x'
+              f'{self._image._image.height}')
+        
+    @property
+    def filename(self):
+        return f'{self._name.replace(" ","_")}.{self._image._image.format.lower()}'
+
+    @property
+    def size(self):
+        return self._image._image.width,self._image._image.height
+
+    def __str__(self):
+        return f' Map: name={self._name}'+'\n'+str(self._image)
+#
+# EOF
+#

pywargame/zuntzu/piece.py

@@ -0,0 +1,37 @@
+# --------------------------------------------------------------------
+class ZTPiece:
+    def __init__(self,front_image,back_image,x,y,terrain,card):
+        self._front   = front_image
+        self._back    = back_image
+        self._terrain = terrain
+        self._card    = card
+        self._x       = x
+        self._y       = y
+
+    @property
+    def two_sides(self):
+        return (self._front        is not None and
+                self._back         is not None)
+
+    @property
+    def size(self):
+        return self.width,self.height
+
+    @property
+    def width(self):
+        return self._front.width
+
+    @property
+    def height(self):
+        return self._front.height
+
+    
+    def __str__(self):
+        return (f'  Piece: '+
+                f'{"card" if self._card else "piece"} '+
+                f'{"terrain" if self._terrain else "piece"} '+
+                f'front={self._front} back={self._back}')
+
+#
+# EOF
+#

pywargame/zuntzu/scenario.py

@@ -0,0 +1,208 @@
+## BEGIN_IMPORTS
+from common import VerboseGuard
+from base import DomInspect
+## END_IMPORTS
+
+# --------------------------------------------------------------------        
+class ZTStack:
+    def __init__(self,x,y,ids,flp,rot):
+        self._x    = x
+        self._y    = y
+        self._ids  = ids
+        self._flip = flp
+        self._rot  = rot
+
+    def translate(self,dx,dy):
+        self._x += dx
+        self._y += dy
+
+    def scale(self,f):
+        self._x *= f
+        self._y *= f
+    
+        
+# --------------------------------------------------------------------        
+class ZTLayout(DomInspect):
+    def __init__(self,elem):
+        self._name    = self._get_attr(elem,'board')
+        self._left    = float(self._get_attr(elem,'left',  -1))
+        self._top     = float(self._get_attr(elem,'top',   -1))
+        self._right   = float(self._get_attr(elem,'right', -1))
+        self._bottom  = float(self._get_attr(elem,'bottom',-1))
+        self._visible = self._get_attr(elem,'visible','true')=='true'
+
+        self._stacks  = [self.parse_stack(s)
+                         for s in self._find_children(elem,'counter','stack')]
+
+    @property
+    def ulx(self):
+        return self._left
+    
+    @property
+    def lrx(self):
+        return self._right
+    
+    @property
+    def uly(self):
+        return self._top
+    
+    @property
+    def lry(self):
+        return self._bottom
+
+    @property
+    def left(self):
+        return int(self._left)
+
+    @property
+    def top(self):
+        return int(self._top)
+    
+    @property
+    def width(self):
+        return int(self._right - self._left+.5)
+
+    @property
+    def height(self):
+        return int(self._bottom - self._top+.5)
+    
+    def parse_stack(self,elem):
+        x   = float(self._get_attr(elem,'x',0))
+        y   = float(self._get_attr(elem,'y',0))
+        # We ignore the `rot` and `Side` attributes for now
+        # More difficult to propagate to the states, which are handled
+        # in VSav.  Could perhaps add a mapping from traits to states
+        # when the traits are flattened there. 
+        ids = []
+        flp = []
+        rot = [] 
+        if elem.tagName == 'counter':
+            ids.append(int(self._get_attr(elem,'id',-1)))
+            flp.append(self._get_attr(elem,'side','')=='Back')
+            rot.append(int(self._get_attr(elem,'rot',0)))
+        else:
+            ids.extend([int(self._get_attr(c,'id',-1))
+                        for c in self._find_children(elem,'counter')])
+            flp.extend([self._get_attr(c,'side','')=='Back'
+                        for c in self._find_children(elem,'counter')])
+            rot.extend([int(self._get_attr(c,'rot',0))
+                        for c in self._find_children(elem,'counter')])
+
+        return ZTStack(x,y,ids,flp,rot)
+            
+    def translate(self,dx,dy):
+        self._left   += dx
+        self._right  += dx
+        self._top    += dy
+        self._bottom += dy
+        for s in self._stacks:
+            s.translate(dx,dy)
+
+    def scale(self,f):
+        self._left   *= f
+        self._right  *= f
+        self._top    *= f
+        self._bottom *= f
+        for s in self._stacks:
+            s.scale(f)
+
+    def __str__(self):
+        return f'Layout "{self._name}" ({len(self._stacks)}: {self.ulx},{self.uly},{self.lrx},{self.lry}'
+            
+# --------------------------------------------------------------------        
+class ZTScenario(DomInspect):
+    def __init__(self,file):        
+        from xml.dom.minidom import parse
+        from pathlib import Path
+        
+        with VerboseGuard(f'Got a scenario {file}') as v:
+            self._dom = parse(file)
+
+            p = Path(file if isinstance(file,str) else file.name)
+
+            self._file = p.stem
+            self._root = self._dom.firstChild
+            self._game = self._get_attr(self._root,'game-box')
+            self._name = self._get_attr(self._root,'scenario-name')
+            self._desc = self._get_attr(self._root,'scenario-description','')
+            self._copy = self._get_attr(self._root,'scenario-copyright','')
+
+            self._layouts = [self.parse_layout(elem)
+                             for elem in
+                             self._root.getElementsByTagName('layout')]
+
+            self.ulx = None
+            self.uly = None
+            self.lrx = None
+            self.lry = None
+            
+            v(f'Bounding box: {self.bounding_box}')
+
+    def parse_layout(self,elem):
+        return ZTLayout(elem)
+
+    def translate(self,dx,dy):
+        with VerboseGuard(f'Translating scenario by {dx},{dy}'):
+            self.ulx = None
+            self.uly = None
+            self.lrx = None
+            self.lry = None
+            
+            for l in self._layouts:
+                l.translate(dx,dy)
+
+    def scale(self,f):
+        with VerboseGuard(f'Scaling scenario by {f}'):
+            self.ulx = None
+            self.uly = None
+            self.lrx = None
+            self.lry = None
+            
+            for l in self._layouts:
+                l.scale(f)
+                
+    def on_map(self,name):
+        return any([l._name == name for l in self._layouts])
+
+    def map_layout(self,name):
+        return [l for l in self._layouts if l._name == name]
+
+    def calc_bounding_box(self,name=None):
+        layouts = self._layouts if name is None else self.map_layout(name)
+        ulx     = int(min([l.ulx for l in layouts])-.5)
+        uly     = int(min([l.uly for l in layouts])-.5)
+        lrx     = int(max([l.lrx for l in layouts])+.5)
+        lry     = int(max([l.lry for l in layouts])+.5)
+        return ulx,uly,lrx,lry
+        
+    @property 
+    def bounding_box(self):
+        '''Cache calculations'''
+        if self.ulx is None or \
+           self.uly is None or \
+           self.lrx is None or \
+           self.lry is None:
+            self.ulx = int(min([l.ulx for l in self._layouts])-.5)
+            self.uly = int(min([l.uly for l in self._layouts])-.5)
+            self.lrx = int(max([l.lrx for l in self._layouts])+.5)
+            self.lry = int(max([l.lry for l in self._layouts])+.5)
+
+        return self.ulx,self.uly,self.lrx,self.lry
+
+    def __str__(self):
+        return f'Scenario "{self._name}": {self._desc}'+'\n'+\
+            '\n'.join([str(l) for l in self._layouts])
+        
+    @property
+    def width(self):
+        x1,_,x2,_ = self.bounding_box
+        return x2-x1 
+    @property
+    def height(self):
+        _,y1,_,y2 = self.bounding_box
+        return y2-y1
+   
+    
+#
+# EOF
+#

pywargame/zuntzu/ztexp.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python
+## BEGIN_IMPORTS
+from sys import path
+path.append('..')
+
+from gamebox import ZTGameBox
+from exporter import ZTExporter
+from common      import Verbose
+from base import ZTImage
+## END_IMPORTS
+
+if __name__ == '__main__':
+    from argparse import ArgumentParser, FileType, \
+         RawDescriptionHelpFormatter 
+    from pathlib import Path
+    from textwrap import wrap, dedent
+
+    w = lambda s : '\n\n'.join(['\n'.join(wrap(p))
+                                for p in dedent(s).split('\n\n')])
+    e = '''
+           If the script fails with "cache resources exhausted",
+           try reducing the resolution (-r).
+
+           If the ZunTzu game box does not have selectable
+           boards, use the -a option to add all boards to
+           the generated VASSAL module.
+
+           Pass a Python script with the option -p to do
+           user post-processing with that script.  Use the
+           pywargame VASSAL API to do all sorts of manipulations.
+           '''
+    
+    ap = ArgumentParser(description='Read in a ZunTzu GameBox',
+                        formatter_class= RawDescriptionHelpFormatter,
+                        epilog=w(e))
+    ap.add_argument('input', type=FileType('rb'), 
+                    help='Input ZunTzu GameBox')
+    ap.add_argument('--output', '-o', type=str, nargs='?',
+                    default='', help='Output VASSAL module')
+    ap.add_argument('-p','--patch',
+                    help='A python script to patch generated module',
+                    type=FileType('r'))
+    ap.add_argument('-V','--verbose',
+                    help='Be verbose',
+                    action='store_true')
+    ap.add_argument('-r','--resolution',help='Set target DPI',type=int,
+                    choices=[75,150,300,600],default=150)
+    ap.add_argument('-a','--all-maps',action='store_true',
+                    help='Generate all maps')
+    ap.add_argument('-1','--one-map',action='store_false',dest='all_maps',
+                    help='All maps are different versions of main map')
+    ap.add_argument('-R','--n-rotations',type=int,
+                    help='Number of rotations to allow. Set to 1 for '
+                    'arbitrary rotations',default=12)
+    ap.add_argument('-W','--vassal-version',
+                    help='Vassal version number',
+                    type=str,
+                    default='3.7.0')
+    ap.add_argument('-S','--symbolic-dice',
+                    help='Use symbolic dice',
+                    action='store_true')
+    ap.add_argument('-T','--text-dice',
+                    help='Use normal text dice',
+                    dest='symbolic_dice',
+                    action='store_false')
+    ap.add_argument('-v','--version',
+                    help='Override version',
+                    type=str,
+                    default='0.0.1')
+    ap.set_defaults(symbolic_dice=True,
+                    all_maps=False)
+
+
+    args = ap.parse_args()
+
+    Verbose().setVerbose(args.verbose)
+
+    ZTImage.target_dpi = args.resolution
+    output = args.output
+    patch  = args.patch 
+    if output == '':
+        p      = Path(args.input.name)
+        output = p.with_suffix('.vmod')
+    if patch is not None:
+        tmp = patch.name
+        patch.close()
+        patch = tmp
+        
+    gb = ZTGameBox(args.input)
+    # gb.write_images()
+    
+    try:
+        exporter = ZTExporter(gb,
+                              version=args.version,
+                              vassalVersion=args.vassal_version,
+                              allmaps=args.all_maps,
+                              nrotations=args.n_rotations,
+                              symbolic_dice=args.symbolic_dice)
+        exporter.run(output,patch)
+    except Exception as e:
+        from sys import stderr 
+        from os import unlink
+        
+        print(f'Failed to build {output}: {e}',file=stderr)
+
+        try:
+            unlink(vmodname)
+        except:
+            pass
+
+        raise e
+        
+#
+# EOF
+#