pywargame 0.3.1__py3-none-any.whl

pywargame/latex/main.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python
+## BEGIN_IMPORTS
+from latexexporter import LaTeXExporter
+from vassal.vmod import VMod
+from common import Verbose
+## END_IMPORTS
+
+from argparse import ArgumentParser
+
+class DefaultSubcommandArgParse(ArgumentParser):
+    _default_subparser = None
+
+    def set_default_subparser(self, name):
+        self._default_subparser = name
+
+    def _parse_known_args(self, arg_strings, *args, **kwargs):
+        from argparse import _SubParsersAction
+        in_args = set(arg_strings)
+        d_sp    = self._default_subparser
+        if d_sp is not None and not {'-h', '--help'}.intersection(in_args):
+            for x in self._subparsers._actions:
+                subparser_found = (
+                    isinstance(x, _SubParsersAction) and
+                    in_args.intersection(x._name_parser_map.keys())
+                )
+                if subparser_found:
+                    break
+            else:
+                # insert default in first position, this implies no
+                # global options without a sub_parsers specified
+                arg_strings = [d_sp] + arg_strings
+        return super(DefaultSubcommandArgParse, self)._parse_known_args(
+            arg_strings, *args, **kwargs
+        )
+# ====================================================================
+def patchIt(args):
+    vmodname  = args.output.name
+    patchname = args.patch.name
+    args.output.close()
+    args.patch .close()
+    
+    VMod.patch(vmodname, patchname, args.verbose)
+
+# ====================================================================
+def exportIt(args):
+
+    vmodname  = args.output.name
+    patchname = args.patch.name if args.patch is not None else None
+
+    args.output.close()
+    if args.patch is not None:
+        args.patch.close()
+
+    Verbose().setVerbose(args.verbose)
+
+    try:
+        if args.version.lower() == 'draft':
+            args.visible_grids = True
+            
+        rulesname = args.rules.name    if args.rules    is not None else None
+        tutname   = args.tutorial.name if args.tutorial is not None else None
+        
+        exporter  = LaTeXExporter(vmodname      = vmodname,
+                                  pdfname       = args.pdffile.name,
+                                  infoname      = args.infofile.name,
+                                  title         = args.title,
+                                  version       = args.version,
+                                  description   = args.description,
+                                  rules         = rulesname,
+                                  tutorial      = tutname,
+                                  patch         = patchname,
+                                  visible       = args.visible_grids,
+                                  vassalVersion = args.vassal_version,
+                                  nonato        = args.no_nato_prototypes,
+                                  nochit        = args.no_chit_information,
+                                  resolution    = args.resolution,
+                                  counterScale  = args.counter_scale,
+                                  imageFormat   = args.image_format)
+        exporter.run()
+    except Exception as e:
+        from sys import stderr 
+        print(f'Failed to build {vmodname}: {e}',file=stderr)
+        from os import unlink
+        try:
+            unlink(vmodname)
+        except:
+            pass
+        
+        raise e
+    
+    
+# ====================================================================
+if __name__ == '__main__':
+    from argparse import ArgumentParser, FileType
+
+    ap = DefaultSubcommandArgParse(description='Create draft VASSAL module')
+    ap.set_default_subparser('export')
+    sp = ap.add_subparsers(dest='mode')
+
+    pp = sp.add_parser('patch',help='Patch VMod')
+    pp.add_argument('output',
+                    help='Module to patch',
+                    type=FileType('r'),
+                    default='Draft.vmod')
+    pp.add_argument('patch',
+                    help='A python script to patch generated module',
+                    type=FileType('r'),
+                    default='patch.py')
+    pp.add_argument('-V','--verbose',
+                    help='Be verbose',
+                    action='store_true')
+
+
+    ep = sp.add_parser('export',help='Export from PDF and JSON to VMod')
+    ep.add_argument('pdffile',
+                    help='The PDF file to read images from',
+                    type=FileType('r'),
+                    default='export.pdf',
+                    nargs='?')
+    ep.add_argument('infofile',
+                    help='The JSON file to read image information from',
+                    type=FileType('r'),
+                    default='export.json',
+                    nargs='?')
+    ep.add_argument('-o','--output',
+                    help='Output file to write module to',
+                    type=FileType('w'),
+                    default='Draft.vmod')
+    ep.add_argument('-p','--patch',
+                    help='A python script to patch generated module',
+                    type=FileType('r'))
+    ep.add_argument('-V','--verbose',
+                    help='Be verbose',
+                    action='store_true')
+    ep.add_argument('-t','--title',
+                    help='Module title', default='Draft',
+                    type=str)
+    ep.add_argument('-v','--version',
+                    help='Module version',
+                    type=str,
+                    default='draft')
+    ep.add_argument('-r','--rules',
+                    help='Rules PDF file',
+                    type=FileType('r'))
+    ep.add_argument('-T','--tutorial',
+                    help='Tutorial (v)log file',
+                    type=FileType('r'))
+    ep.add_argument('-d','--description',
+                    help='Short description of module',
+                    type=str,
+                    default='draft of module')
+    ep.add_argument('-W','--vassal-version',
+                    help='Vassal version number',
+                    type=str,
+                    default='3.7.12')
+    ep.add_argument('-G','--visible-grids',
+                    action='store_true',
+                    help='Make grids visible in the module')
+    ep.add_argument('-N','--no-nato-prototypes',
+                    action='store_true',
+                    help='Do not make prototypes for types,echelons,commands')
+    ep.add_argument('-C','--no-chit-information',
+                    action='store_true',
+                    help='Do not make properties from chit information')
+    ep.add_argument('-S','--counter-scale',
+                    type=float, default=1,
+                    help='Scale counters by factor')
+    ep.add_argument('-R','--resolution',
+                    type=int, default=150,
+                    help='Resolution of images')
+    ep.add_argument('-I','--image-format',
+                    choices = ['png','svg'], default='png',
+                    help='Image format to use')
+    
+    args = ap.parse_args()
+    
+    if args.mode == 'patch':
+        patchIt(args)
+    else:
+        exportIt(args)
+        
+#
+# EOF
+#

pywargame/vassal/__init__.py

@@ -0,0 +1,66 @@
+'''
+Module to manipulate a VASSAL module (VMOD)
+'''
+from . base import *
+from . element import *
+from . folder import *
+from . globalkey import *
+from . gameelements import *
+from . mapelements import *
+from . globalproperty import *
+from . turn import *
+from . documentation import *
+from . player import *
+from . widget import *
+from . grid import *
+from . zone import *
+from . board import *
+from . map import *
+from . chart import *
+from . command import *
+from . trait import *
+from . withtraits import *
+from . extension import *
+from . traits.area import *
+from . traits.clone import *
+from . traits.dynamicproperty import *
+from . traits.globalproperty import *
+from . traits.prototype import *
+from . traits.place import *
+from . traits.report import *
+from . traits.calculatedproperty import *
+from . traits.restrictcommand import *
+from . traits.label import *
+from . traits.layer import *
+from . traits.globalcommand import *
+from . traits.globalhotkey import *
+from . traits.nostack import *
+from . traits.deselect import *
+from . traits.restrictaccess import *
+from . traits.rotate import *
+from . traits.stack import *
+from . traits.mark import *
+from . traits.mask import *
+from . traits.trail import *
+from . traits.delete import *
+from . traits.sendto import *
+from . traits.moved import *
+from . traits.skel import *
+from . traits.submenu import *
+from . traits.basic import *
+from . traits.trigger import *
+from . traits.nonrect import *
+from . traits.click import *
+from . traits.mat import MatTrait
+from . traits.cargo import CargoTrait
+from . traits.movefixed import MoveFixedTrait
+from . traits.sheet import SheeTrait
+from . traits.hide import HideTrait
+from . traits.return import ReturnTrait
+from . game import *
+from . buildfile import *
+from . moduledata import *
+from . save import *
+from . vsav import *
+from . vmod import *
+from . exporter import *

pywargame/vassal/base.py

@@ -0,0 +1,139 @@
+# ====================================================================
+# Key encoding
+SHIFT = 65
+CTRL = 130
+ALT   = 520
+CTRL_SHIFT = CTRL+SHIFT
+ALT_SHIFT = ALT+SHIFT
+NONE = '\ue004'
+NONE_MOD = 0
+
+# --------------------------------------------------------------------
+def key(let,mod=CTRL):
+
+    '''Encode a key sequence
+
+    down  = 40,0
+    up    = 38,0
+    left  = 37,0
+    right = 39,0
+
+    Parameters
+    ----------
+    let : str
+        Key code (Letter)
+    mod : int
+        Modifier mask
+    '''
+    if let is None:
+        return f'{ord(NONE)},{NONE_MOD}'
+    return f'{ord(let)},{mod}'
+
+# --------------------------------------------------------------------
+#
+def hexcolor(s):
+    if isinstance(s,str):
+        s = s.replace('0x','')
+        if len(s) == 3:
+            r, g, b = [int(si,16)/16 for si in s]
+        elif len(s) == 6:
+            r = int(s[0:2],16) / 256
+            g = int(s[2:4],16) / 256
+            b = int(s[4:6],16) / 256
+        else:
+            raise RuntimeError('3 or 6 hexadecimal digits for color string')
+    elif isinstance(s,int):
+        r = ((s >> 16) & 0xFF) / 256
+        g = ((s >>  8) & 0xFF) / 256
+        b = ((s >>  0) & 0xFF) / 256
+    else:
+        raise RuntimeError('Hex colour must be string or integer')
+
+    return rgb(int(r*256),int(g*256),int(b*256))
+    
+# --------------------------------------------------------------------
+# Colour encoding 
+def rgb(r,g,b):
+    '''Encode RGB colour
+
+    Parameters
+    ----------
+    r : int
+        Red channel
+    g : int
+        Green channel
+    b : int
+        Blue channel
+
+    Returns
+    -------
+    colour : str
+        RGB colour as a string
+    '''
+    return ','.join([str(r),str(g),str(b)])
+
+# --------------------------------------------------------------------
+def rgba(r,g,b,a):
+    '''Encode RGBA colour
+
+    Parameters
+    ----------
+    r : int
+        Red channel
+    g : int
+        Green channel
+    b : int
+        Blue channel
+    a : int
+        Alpha channel
+    
+    Returns
+    -------
+    colour : str
+        RGBA colour as a string
+    '''
+    return ','.join([str(r),str(g),str(b),str(a)])
+
+# --------------------------------------------------------------------
+def dumpTree(node,ind=''):
+    '''Dump the tree of nodes
+
+    Parameters
+    ----------
+    node : xml.dom.Node
+        Node to dump
+    ind : str
+        Current indent 
+    '''
+    print(f'{ind}{node}')
+    for c in node.childNodes:
+        dumpTree(c,ind+' ')
+
+# --------------------------------------------------------------------
+def registerElement(cls,uniqueAttr=[],tag=None):
+    '''Register a TAG to element class, as well as unique attributes
+    to compare when comparing objects of that element class.
+
+    '''
+## BEGIN_IMPORT
+    from . element import Element
+## END_IMPORT
+
+    # Get class-level definitions of UNIQUE
+    uniqueCls = getattr(cls,'UNIQUE',None)
+    if uniqueCls:
+        try:
+            iter(uniqueCls)
+        except:
+            uniqueCls = list(uniqueCls)
+    else:
+        uniqueCls = []    
+        
+    tagName = cls.TAG if tag is None else tag 
+    Element.known_tags  [tagName] = cls
+    Element.unique_attrs[tagName] = uniqueAttr+uniqueCls
+    
+        
+#
+# EOF
+#

pywargame/vassal/board.py

@@ -0,0 +1,243 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . base import *
+from . element import Element
+from . gameelements import GameElement
+from . mapelements import MapElement
+from . zone import *
+from . grid import *
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class BoardPicker(MapElement):
+    TAG = Element.MAP+'BoardPicker'
+    def __init__(self,doc,node=None,
+                 addColumnText        = 'Add column',
+                 addRowText           = 'Add row',
+                 boardPrompt          = 'Select board',
+                 slotHeight           = 125,
+                 slotScale            = 0.2,
+                 slotWidth            = 350,
+                 title                = 'Choose Boards'):
+        super(BoardPicker,self).__init__(doc,self.TAG,node=node,
+                                         addColumnText        = addColumnText,
+                                         addRowText           = addRowText,
+                                         boardPrompt          = boardPrompt,
+                                         slotHeight           = slotHeight,
+                                         slotScale            = slotScale,
+                                         slotWidth            = slotWidth,
+                                         title                = title,
+                                         selected             = '')
+
+    def addSetup(self,**kwargs):
+        '''Add a `Setup` element to this
+
+        Parameters
+        ----------
+        kwargs : dict
+            Dictionary of attribute key-value pairs
+        
+        Returns
+        -------
+        element : Setup
+            The added element
+        '''
+        if 'mapName' not in kwargs:
+            m = self.getMap()
+            kwargs['mapName'] = m.getAttribute('mapName')
+            
+        return self.add(Setup,**kwargs)
+    def getSetups(self,single=False):
+        '''Get all or a sole `Setup` element(s) from this
+
+        Parameters
+        ----------
+        single : bool
+            If `True`, there can be only one `Setup` child, otherwise fail.
+            If `False` return all `Setup` children in this element
+        
+        Returns
+        -------
+        children : list
+            List of `Setup` children (even if `single=True`)
+        '''
+        return self.getAllElements(Setup,single=single)
+    def addBoard(self,**kwargs):
+        '''Add a `Board` element to this
+
+        Parameters
+        ----------
+        kwargs : dict
+            Dictionary of attribute key-value pairs
+        
+        Returns
+        -------
+        element : Board
+            The added element
+        '''
+        return self.add(Board,**kwargs)
+    def getBoards(self,asdict=True):
+        '''Get all Board element(s) from this
+
+        Parameters
+        ----------
+        asdict : bool
+            If `True`, return a dictonary that maps key to `Board` elements.  If `False`, return a list of all Board` children.
+        
+        Returns
+        -------
+        children : dict or list
+            Dictionary or list of `Board` children
+        '''
+        return self.getElementsByKey(Board,'name',asdict=asdict)
+    
+    def selectBoard(self,name):
+        if name is None:
+            self.setAttribute('selected','')
+            return
+        
+        if name not in self.getBoards():
+            print(f'Board "{name}" not in "{self.getMap()["mapName"]}" picker')
+            return
+
+        escname = name.replace('|',' ')
+        self.setAttribute('selected',f'{self["selected"]}|{name}|')
+        #print(f'Added "{name}" to selected boards: {self["selected"]}')
+        
+    def encode(self):
+        setups = self.getSetups()
+        if setups is not None and len(setups)>0:
+            return [setups[0]._node.childNodes[0].nodeValue]
+        
+        ret    = []
+        selected = self['selected']
+        #print(f'Selected boards: {selected}')
+        for bn in self.getBoards().keys():
+            escname = '|'+bn.replace('|',' ')+'|'
+            # if selected != '':
+            #     print(f'Ignore board "{bn}" in map '
+            #           f'{self.getMap()["mapName"]} '
+            #           f'"{selected}" -> '
+            #           f'{escname not in selected}')
+            if escname not in selected:
+                continue 
+            ret.append(self.getMap()['mapName']+'BoardPicker\t'+bn+'\t0\t0')
+
+        return ret
+
+registerElement(BoardPicker)
+
+# --------------------------------------------------------------------
+class Setup(Element):
+    TAG = 'setup'
+    def __init__(self,picker,node=None,
+                 mapName = '',
+                 maxColumns = 1,
+                 boardNames = []):
+        super(Setup,self).__init__(picker,self.TAG,node=node)
+        col = 0
+        row = 0
+        lst = [f'{mapName}BoardPicker']
+        for bn in boardNames:
+            lst.extend([bn,str(col),str(row)])
+            col += 1
+            if col >= maxColumns:
+                col = 0
+                row += 1
+                
+        txt = r'	'.join(lst)
+        self.addText(txt)
+
+    def getPicker(self): return self.getParent(BoardPicker)
+
+registerElement(Setup)
+    
+# --------------------------------------------------------------------
+class Board(Element):
+    TAG = Element.PICKER+'Board'
+    UNIQUE = ['name']
+    def __init__(self,picker,node=None,
+                 name       = '',
+                 image      = '',
+                 reversible = False,
+                 color      = rgb(255,255,255),
+                 width      = 0,
+                 height     = 0):
+        super(Board,self).__init__(picker,self.TAG,node=node,
+                                   image      = image,
+                                   name       = name,
+                                   reversible = reversible,
+                                   color      = color,
+                                   width      = width,
+                                   height     = height)
+
+    def getPicker(self): return self.getParent(BoardPicker)
+    def getMap(self):
+        z = self.getPicker()
+        if z is not None:
+            return z.getMap()
+        return None
+    def addZonedGrid(self,**kwargs):
+        '''Add a `ZonedGrid` element to this
+
+        Parameters
+        ----------
+        kwargs : dict
+            Dictionary of attribute key-value pairs
+        
+        Returns
+        -------
+        element : ZonedGrid
+            The added element
+        '''
+        return self.add(ZonedGrid,**kwargs)
+    def getZonedGrids(self,single=True):
+        '''Get all or a sole `ZonedGrid` element(s) from this
+
+        Parameters
+        ----------
+        single : bool
+            If `True`, there can be only one `ZonedGrid` child, otherwise fail.
+            If `False` return all `ZonedGrid` children in this element
+        
+        Returns
+        -------
+        children : list
+            List of `ZonedGrid` children (even if `single=True`)
+        '''
+        return self.getAllElements(ZonedGrid,single=single)
+    def getZones(self,asdict=True):
+        '''Get all Zone element(s) from this
+
+        Parameters
+        ----------
+        asdict : bool
+            If `True`, return a dictonary that maps key to `Zone` elements.  If `False`, return a list of all Zone` children.
+        
+        Returns
+        -------
+        children : dict or list
+            Dictionary or list of `Zone` children
+        '''
+        zoned = self.getZonedGrids(single=True)
+        if zoned is None: return None
+
+        return zoned[0].getZones(asdict=asdict)
+
+    def getWidth(self):
+        # print(f'Getting width of {self}: {self["width"]}')
+        if 'width' in self and int(self['width']) != 0:
+            return int(self['width'])
+        return 0
+
+    def getHeight(self):
+        # print(f'Getting height of {self}: {self["height"]}')
+        if 'height' in self and int(self['height']) != 0:
+            return int(self['height'])
+        return 0
+
+registerElement(Board)
+
+#
+# EOF
+#

pywargame/vassal/buildfile.py

@@ -0,0 +1,60 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . base import *
+from . element import Element
+from . game import Game
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class BuildFile(Element):
+    def __init__(self,root=None):
+        '''Construct from a DOM object, if given, otherwise make new'''
+        # from xml.dom.minidom import Document
+        super(BuildFile,self).__init__(None,'',None)
+        
+        self._root = root
+        self._tag  = 'buildFile'
+        if self._root is None:
+            self._root = xmlns.Document()
+
+        self._node = self._root
+
+    def addGame(self,**kwargs):
+        '''Add a `Game` element to this
+
+        Parameters
+        ----------
+        kwargs : dict
+            Dictionary of attribute key-value pairs
+        
+        Returns
+        -------
+        element : Game
+            The added element
+        '''
+        return Game(self,**kwargs)
+
+    def getGame(self):
+        '''Get the `Game`'''
+        try:
+            return Game(self,
+                        node=self._root.\
+                        getElementsByTagName('VASSAL.build.GameModule')[0])
+        except:
+            pass
+
+        return Game(self,
+                    node=self._root.\
+                    getElementsByTagName('VASSAL.launch.BasicModule')[0])
+                    
+
+    def encode(self):
+        '''Encode into XML'''
+        return self._root.toprettyxml(indent=' ',
+                                      encoding="UTF-8",
+                                      standalone=False)
+
+
+#
+# EOF
+#