pywargame 0.3.1__py3-none-any.whl

pywargame/vassal/skel.py

@@ -0,0 +1,380 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . base import *
+from . element import Element
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class GameElement(Element):
+    def __init__(self,game,tag,node=None,**kwargs):
+        super(GameElement,self).__init__(game,tag,node=node,**kwargs)
+
+    def getGame(self):
+        return self.getParent(Game)
+    
+
+# --------------------------------------------------------------------
+class Notes(GameElement):
+    TAG = Element.MODULE+'NotesWindow'
+    def __init__(self,elem,node=None,
+                 name             = 'Notes',
+                 buttonText       = '',
+                 hotkey           = key('N',ALT),
+                 icon             = '/images/notes.gif',
+                 tooltip          = 'Show notes window'):
+        super(Notes,self).__init__(elem,self.TAG,node=node,
+                                   name       = name,
+                                   buttonText = buttonText,
+                                   hotkey     = hotkey,
+                                   icon       = icon,
+                                   tooltip    = tooltip)
+    def encode(self):
+        return ['NOTES\t\\','PNOTES']
+
+registerElement(Notes)
+
+# --------------------------------------------------------------------
+class PredefinedSetup(GameElement):
+    TAG = Element.MODULE+'PredefinedSetup'
+    def __init__(self,elem,node=None,
+                 name             = '',
+                 file             = '',
+                 useFile          = False,
+                 isMenu           = False,
+                 description      = ''):
+        useFile = ((useFile or not isMenu) and
+                   (file is not None and len(file) > 0))
+        if file is None: file = ''
+        super(PredefinedSetup,self).__init__(elem,self.TAG,node=node,
+                                             name        = name,
+                                             file        = file,
+                                             useFile     = useFile,
+                                             isMenu      = isMenu,
+                                             description = description)
+    def addPredefinedSetup(self,**kwargs):
+        '''Add a `PredefinedSetup` element to this
+
+        Parameters
+        ----------
+        kwargs : dict
+            Dictionary of attribute key-value pairs
+        Returns
+        -------
+        element : PredefinedSetup
+            The added element
+        '''
+        return self.add(PredefinedSetup,**kwargs)
+    def getPredefinedSetups(self,asdict=True):
+        '''Get all PredefinedSetup element(s) from this
+
+        Parameters
+        ----------
+        asdict : bool
+            If `True`, return a dictonary that maps key to `PredefinedSetup` elements.  If `False`, return a list of all PredefinedSetup` children.
+        Returns
+        -------
+        children : dict or list
+            Dictionary or list of `PredefinedSetup` children
+        '''
+        return self.getElementsByKey(PredefinedSetup,'name',asdict)
+        
+    
+        
+                   
+registerElement(PredefinedSetup)
+                  
+# --------------------------------------------------------------------
+class GlobalTranslatableMessages(GameElement):
+    TAG=Element.MODULE+'properties.GlobalTranslatableMessages'
+    def __init__(self,elem,node=None):
+        '''Translations
+
+        Parameters
+        ----------
+        doc : Element
+            Parent
+        node : xml.dom.Element
+            Node to read state from
+        '''
+        super(GlobalTranslatableMessages,self).\
+            __init__(elem,self.TAG,node=node)
+
+registerElement(GlobalTranslatableMessages)
+                  
+# --------------------------------------------------------------------
+class Language(GameElement):
+    TAG = 'VASSAL.i18n.Language'
+    def __init__(self,elem,node=None,**kwargs):
+        super(Languate,self).__init__(sele,self.TAG,node=none,**kwargs)
+        
+registerElement(Language)
+                  
+# --------------------------------------------------------------------
+class Chatter(GameElement):
+    TAG=Element.MODULE+'Chatter'
+    def __init__(self,elem,node=None,**kwargs):
+        '''Chat
+
+        Parameters
+        ----------
+        doc : Element
+            Parent
+        node : xml.dom.Element
+            Node to read state from
+        kwargs : dict
+            Attributes
+        '''
+        super(Chatter,self).__init__(elem,self.TAG,node=node,**kwargs)
+        
+registerElement(Chatter)
+                  
+# --------------------------------------------------------------------
+class KeyNamer(GameElement):
+    TAG=Element.MODULE+'KeyNamer'
+    def __init__(self,elem,node=None,**kwargs):
+        '''Key namer (or help menu)
+
+        Parameters
+        ----------
+        doc : Element
+            Parent
+        node : xml.dom.Element
+            Node to read state from
+        kwargs : dict
+            Attributes
+        '''
+        super(KeyNamer,self).__init__(elem,self.TAG,node=node,**kwargs)
+        
+registerElement(KeyNamer)
+
+# --------------------------------------------------------------------
+class GlobalOptions(GameElement):
+    TAG = Element.MODULE+'GlobalOptions'
+    def __init__(self,doc,node=None,
+                 autoReport               = "Use Preferences Setting",
+                 centerOnMove             = "Use Preferences Setting",
+                 chatterHTMLSupport       = "Always",
+                 hotKeysOnClosedWindows   = "Never",
+                 inventoryForAll          = "Always",
+                 nonOwnerUnmaskable       = "Use Preferences Setting",
+                 playerIdFormat           = "$playerName$",
+                 promptString             = "Opponents can unmask pieces",
+                 sendToLocationMoveTrails = "Never"):
+        '''Set global options on the module
+
+        Parameters
+        ----------
+        doc : Element
+            Parent
+        node : xml.dom.Element
+            Node to read state from 
+        autoReport               : str Option
+        centerOnMove             : str Option
+        chatterHTMLSupport       : str Option
+        hotKeysOnClosedWindows   : str Option
+        inventoryForAll          : str Option
+        nonOwnerUnmaskable       : str Option
+        playerIdFormat           : str Option
+        promptString             : str Option
+        sendToLocationMoveTrails : str Option
+        '''
+        super(GlobalOptions,self).\
+            __init__(doc,self.TAG,node=node,
+                     autoReport               = autoReport,
+                     centerOnMove             = centerOnMove,
+                     chatterHTMLSupport       = chatterHTMLSupport,
+                     hotKeysOnClosedWindows   = hotKeysOnClosedWindows,
+                     inventoryForAll          = inventoryForAll,
+                     nonOwnerUnmaskable       = nonOwnerUnmaskable,
+                     playerIdFormat           = playerIdFormat,
+                     promptString             = promptString,
+                     sendToLocationMoveTrails = sendToLocationMoveTrails)
+
+    def addOption(self,**kwargs):
+        '''Add a `Option` element to this
+
+        Parameters
+        ----------
+        kwargs : dict
+            Dictionary of attribute key-value pairs
+        Returns
+        -------
+        element : Option
+            The added element
+        '''
+        return self.add(Option,**kwargs)
+    def getOptions(self):
+        return self.getElementsByKey(Option,'name')
+    
+registerElement(GlobalOptions)
+
+
+# --------------------------------------------------------------------
+class Option(Element):
+    TAG = 'option'
+    def __init__(self,doc,node=None,name='',value=''):
+        super(Option,self).__init__(doc,node=node,name=name)
+        self._root.addText(self._node,value)
+
+    def getGlobalOptions(self):
+        return self.getParent(GlobalOptions)
+    
+registerElement(Option)
+
+# --------------------------------------------------------------------
+# CurrentMap == "Board"
+class Inventory(GameElement):
+    TAG = Element.MODULE+'Inventory'
+    def __init__(self,doc,node=None,
+                  canDisable          = False,
+                  centerOnPiece       = True,
+                  disabledIcon        = '',
+                  drawPieces          = True,
+                  foldersOnly         = False,
+                  forwardKeystroke    = True,
+                  groupBy             = '',
+                  hotkey              = key('I',ALT),
+                  icon                = '/images/inventory.gif',
+                  include             = '{}',
+                  launchFunction      = 'functionHide',
+                  leafFormat          = '$PieceName$',
+                  name                = '',
+                  nonLeafFormat       = '$PropertyValue$',
+                  pieceZoom           = '0.33',
+                  pieceZoom2          = '0.5',
+                  pieceZoom3          = '0.6',
+                  propertyGate        = '',
+                  refreshHotkey       = key('I',ALT_SHIFT),
+                  showMenu            = True,
+                  sides               = '',
+                  sortFormat          = '$PieceName$',
+                  sortPieces          = True,
+                  sorting             = 'alpha',
+                  text                = '',
+                  tooltip             = 'Show inventory of all pieces',
+                  zoomOn              = False):
+        super(Inventory,self).__init__(doc,self.TAG,node=node,
+                                       canDisable          = canDisable,
+                                       centerOnPiece       = centerOnPiece,
+                                       disabledIcon        = disabledIcon,
+                                       drawPieces          = drawPieces,
+                                       foldersOnly         = foldersOnly,
+                                       forwardKeystroke    = forwardKeystroke,
+                                       groupBy             = groupBy,
+                                       hotkey              = hotkey,
+                                       icon                = icon,
+                                       include             = include,
+                                       launchFunction      = launchFunction,
+                                       leafFormat          = leafFormat,
+                                       name                = name,
+                                       nonLeafFormat       = nonLeafFormat,
+                                       pieceZoom           = pieceZoom,
+                                       pieceZoom2          = pieceZoom2,
+                                       pieceZoom3          = pieceZoom3,
+                                       propertyGate        = propertyGate,
+                                       refreshHotkey       = refreshHotkey,
+                                       showMenu            = showMenu,
+                                       sides               = sides,
+                                       sortFormat          = sortFormat,
+                                       sortPieces          = sortPieces,
+                                       sorting             = sorting,
+                                       text                = text,
+                                       tooltip             = tooltip,
+                                       zoomOn              = zoomOn)
+                  
+registerElement(Inventory)
+
+# --------------------------------------------------------------------
+class Prototypes(GameElement):
+    TAG = Element.MODULE+'PrototypesContainer'
+    def __init__(self,game,node=None,**kwargs):
+        super(Prototypes,self).\
+            __init__(game,self.TAG,node=node,**kwargs)
+
+    def addPrototype(self,**kwargs):
+        '''Add a `Prototype` element to this
+
+        Parameters
+        ----------
+        kwargs : dict
+            Dictionary of attribute key-value pairs
+        Returns
+        -------
+        element : Prototype
+            The added element
+        '''
+        return self.add(Prototype,**kwargs)
+    def getPrototypes(self,asdict=True):
+        '''Get all Prototype element(s) from this
+
+        Parameters
+        ----------
+        asdict : bool
+            If `True`, return a dictonary that maps key to `Prototype` elements.  If `False`, return a list of all Prototype` children.
+        Returns
+        -------
+        children : dict or list
+            Dictionary or list of `Prototype` children
+        '''
+        return self.getElementsByKey(Prototype,'name',asdict=asdict)
+        
+    
+
+registerElement(Prototypes)
+
+# --------------------------------------------------------------------
+class DiceButton(GameElement):
+    TAG=Element.MODULE+'DiceButton'
+    def __init__(self,elem,node=None,
+                 addToTotal           = 0,
+                 canDisable           = False,
+                 hotkey               = key('6',ALT),
+                 icon                 = '/images/die.gif',
+                 keepCount            = 1,
+                 keepDice             = False,
+                 keepOption           = '>',
+                 lockAdd              = False,
+                 lockDice             = False,
+                 lockPlus             = False,
+                 lockSides            = False,
+                 nDice                = 1,
+                 nSides               = 6,
+                 name                 = '1d6',
+                 plus                 = 0,
+                 prompt               = False,
+                 propertyGate         = '',
+                 reportFormat         = '** $name$ = $result$ *** <$PlayerName$>;',
+                 reportTotal          = False,
+                 sortDice             = False,
+                 text                 = '1d6',
+                 tooltip              = 'Roll a 1d6'):
+        super(DiceButton,self).\
+            __init__(elem,self.TAG,node=node,
+                     addToTotal           = addToTotal,
+                     canDisable           = canDisable,
+                     hotkey               = hotkey,
+                     icon                 = icon,
+                     keepCount            = keepCount,
+                     keepDice             = keepDice,
+                     keepOption           = keepOption,
+                     lockAdd              = lockAdd,
+                     lockDice             = lockDice,
+                     lockPlus             = lockPlus,
+                     lockSides            = lockSides,
+                     nDice                = nDice,
+                     nSides               = nSides,
+                     name                 = name,
+                     plus                 = plus,
+                     prompt               = prompt,
+                     propertyGate         = propertyGate,
+                     reportFormat         = reportFormat,
+                     reportTotal          = reportTotal,
+                     sortDice             = sortDice,
+                     text                 = text,
+                     tooltip              = tooltip)
+
+registerElement(DiceButton)
+
+#
+# EOF
+#

pywargame/vassal/trait.py

@@ -0,0 +1,224 @@
+# ====================================================================
+class Trait:
+    known_traits = []
+    def __init__(self):
+        '''Base class for trait capture.
+        
+        Unlike the Element classes, this actually holds state that
+        isn't reflected elsewhere in the DOM.  This means that the
+        data here is local to the object.  So when we do
+        
+            piece  = foo.getPieceSlots()[0]
+            traits = p.getTraits()
+            for trait in traits:
+                if trait.ID == 'piece': 
+                    trait["gpid"] = newPid
+                    trait["lpid"] = newPid
+        
+        we do not actually change anything in the DOM.  To do that, we
+        must add back _all_ the traits as
+        
+            piece.setTraits(traits)
+        
+        We can add traits to a piece, like
+        
+            piece.addTrait(MarkTrait('Hello','World'))
+        
+        But it is not particularly efficient.  Better to do
+        (continuing from above)
+        
+            traits.append(MarkTrait('Hello','World;)
+            piece.setTraits(traits)
+        
+        .. include:: ../../vassal/traits/README.md
+           :parser: myst_parser.sphinx_
+        
+        '''
+        self._type  = None
+        self._state = None
+
+    def setType(self,**kwargs):
+        '''Set types.  Dictionary of names and values.  Dictonary keys
+        defines how we access the fields, which is internal here.
+        What matters is the order of the values.
+
+        '''
+        self._type   = list(kwargs.values())
+        self._tnames = list(kwargs.keys())
+
+    def setState(self,**kwargs):
+        '''Set states.  Dictionary of names and values.  Dictonary keys
+        defines how we access the fields, which is internal here.
+        What matters is the order of the values.
+        '''
+        self._state  = list(kwargs.values())
+        self._snames = list(kwargs.keys())
+
+    def __getitem__(self,key):
+        '''Look up item in either type or state'''
+        try:
+            return self._type[self._tnames.index(key)]
+        except:
+            pass
+        return self._state[self._snames.index(key)]
+
+    def __setitem__(self,key,value):
+        '''Set item in either type or state'''
+        try:
+            self._type[self._tnames.index(key)] = value
+            return
+        except:
+            pass
+        self._state[self._snames.index(key)] = value
+
+    def encode(self,term=False):
+        '''
+        returns type and state encoded'''
+        t = self.encodeFields(self.ID,*self._type,term=term)
+        s = self.encodeFields(*self._state,term=term)
+        return t,s
+
+    @classmethod
+    def findTrait(cls,traits,ID,key=None,value=None,verbose=False):
+        for trait in traits:
+            if trait.ID != ID:
+                continue
+            if verbose:
+                print(f' {trait.ID}')
+            if key is None or value is None:
+                if verbose:
+                    print(f' Return {trait.ID}')
+                return trait
+            if verbose:
+                print(f' Check {key}={value}: {trait[key]}')
+            if trait[key] == value:
+                return trait
+        if verbose:
+            print(f' Trait of type {ID} with {key}={value} not found')
+        return None
+        
+    @classmethod
+    def take(cls,iden,t,s):
+        '''If the first part of the string t matches the ID, then take it.
+
+        t and s are lists of strings.
+        ''' 
+        if iden != cls.ID: return None
+
+        ret = cls()
+        ret._type = t
+        ret._state = s
+        ret.check() # Check if we're reasonable, or raise
+        #print(f'Took {iden} {cls}\n'
+        #      f'  {ret._tnames}\n'
+        #      f'  {ret._snames}')
+        return ret
+
+    def check(self):
+        '''Implement if trait should check that all is OK when cloning'''
+        pass
+
+    @classmethod
+    def encodeFields(cls,*args,term=False):
+        return ';'.join([str(e).lower() if isinstance(e,bool) else str(e)
+                         for e in args])+(';' if term else '')
+
+    @classmethod
+    def decodeFields(cls,s):
+        from re import split
+        return split(r'(?<!\\);',s)
+        # return s.split(';') # Probably too simple-minded 
+
+    @classmethod
+    def encodeKeys(cls,keys,sep=','):
+        return sep.join([k.replace(',','\\'+f'{sep}') for k in keys])
+        
+    @classmethod
+    def decodeKeys(cls,keys,sep=','):
+        from re import split
+        ks = split(r'(?<!\\)'+f'{sep}',keys)
+        return [k.replace('\\'+f'{sep}',f'{sep}') for k in ks]
+
+    @classmethod
+    def flatten(cls,traits,game=None,prototypes=None,verbose=False):
+## BEGIN_IMPORT        
+        from . traits import BasicTrait
+## END_IMPORT        
+        if prototypes is None:
+            if game is None:
+                print(f'Warning: Game or prototypes not passed')
+                return None
+            prototypes = game.getPrototypes()[0].getPrototypes()
+
+        if len(traits) < 1: return None
+
+        basic = None
+        if traits[-1].ID == 'piece': # BasicTrait.ID:
+            basic = traits.pop()
+
+        if verbose:
+            print(f'Piece {basic["name"]}')
+            
+        ret = cls._flatten(traits,prototypes,' ',verbose)
+        ret.append(basic)
+
+        return ret
+    
+    @classmethod
+    def _flatten(cls,traits,prototypes,ind,verbose):
+## BEGIN_IMPORT        
+        from . traits import BasicTrait
+        from . traits import PrototypeTrait
+## END_IMPORT        
+        '''Expand all prototype traits in traits'''
+        ret = []
+        for trait in traits:
+            # Ignore recursive basic traits
+            if trait.ID == BasicTrait.ID:
+                continue
+            # Add normal traits
+            if trait.ID != PrototypeTrait.ID:
+                if verbose:
+                    print(f'{ind}Adding trait "{trait.ID}"')
+                    
+                ret.append(trait)
+                continue
+
+            # Find prototype
+            name  = trait['name']
+            proto = prototypes.get(name,None)
+            if proto is None:
+                if name != ' prototype':
+                    print(f'{ind}Warning, prototype {name} not found')
+                continue
+
+            if verbose:
+                print(f'{ind}Expanding prototype "{name}"')
+                
+            # Recursive call to add prototype traits (and possibly
+            # more recursive calls 
+            ret.extend(cls._flatten(proto.getTraits(), prototypes,
+                                    ind+' ',verbose))
+
+        return ret
+
+    def print(self,file=None):
+        if file is None:
+            from sys import stdout
+            file = stdout
+
+        nt = max([len(i) for i in self._tnames]) if self._tnames else 0
+        ns = max([len(i) for i in self._snames]) if self._snames else 0
+        nw = max(nt,ns)
+
+        print(f'Trait ID={self.ID}',file=file)
+        print(f' Type:',            file=file)
+        for n,v in zip(self._tnames,self._type):
+            print(f'  {n:<{nw}s}: {v}',file=file)
+        print(f' State:',           file=file)
+        for n,v in zip(self._snames,self._state):
+            print(f'  {n:<{nw}s}: {v}',file=file)
+            
+#
+# EOF
+#

pywargame/vassal/traits/__init__.py

@@ -0,0 +1,36 @@
+#
+from . area import AreaTrait
+from . basic import BasicTrait
+from . calculatedproperty import CalculatedTrait
+from . clone import CloneTrait
+from . delete import DeleteTrait
+from . globalcommand import GlobalCommandTrait
+from . globalhotkey import GlobalHotkeyTrait
+from . dynamicproperty import *
+from . nostack import *
+from . deselect import *
+from . globalproperty import GlobalPropertyTrait
+from . label import LabelTraitCodes, LabelTrait
+from . layer import LayerTrait
+from . mark import MarkTrait
+from . mask import MaskTrait
+from . moved import MovedTrait
+from . place import PlaceTrait
+from . prototype import PrototypeTrait
+from . report import ReportTrait
+from . restrictaccess import RestrictAccessTrait
+from . restrictcommand import RestrictCommandsTrait
+from . rotate import RotateTrait
+from . sendto import SendtoTrait
+from . stack import StackTrait
+from . submenu import SubMenuTrait
+from . trail import TrailTrait
+from . trigger import TriggerTrait
+from . nonrect import NonRectangleTrait
+from . click import ClickTrait
+from . mat import MatTrait
+from . cargo import CargoTrait
+from . movefixed import MoveFixedTrait
+from . sheet import SheetTrait
+from . hide import HideTrait
+from . return import ReturnTrait

pywargame/vassal/traits/area.py

@@ -0,0 +1,50 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import rgb, key
+## END_IMPORT
+
+class AreaTrait(Trait):
+    ID = 'AreaOfEffect'
+    def __init__(self,
+                 transparancyColor = rgb(0x77,0x77,0x77),
+                 transparancyLevel = 30,
+                 radius            = 1,
+                 alwaysActive      = False,
+                 activateCommand   = 'Toggle area of effect',
+                 activateKey       = key('A'), # Ctrl-A
+                 mapShaderName     = '',
+                 fixedRadius       = True,
+                 radiusMarker      = '', # Property
+                 description       = 'Show area of effect',
+                 name              = 'EffectArea',
+                 onMenuText        = '', # Show area of effect
+                 onKey             = '', # key('A')
+                 offMenuText       = '', # Hide area of effect
+                 offKey            = '', # key(A,SHIFT)
+                 globallyVisible   = True):
+        super(AreaTrait,self).__init__()
+        self.setType(
+                 transparancyColor = transparancyColor,
+                 transparancyLevel = int(transparancyLevel),
+                 radius            = radius,
+                 alwaysActive      = alwaysActive,
+                 activateCommand   = activateCommand,
+                 activateKey       = activateKey,
+                 mapShaderName     = mapShaderName,
+                 fixedRadius       = fixedRadius,
+                 radiusMarker      = radiusMarker,
+                 description       = description,
+                 name              = name,
+                 onMenuText        = onMenuText,
+                 onKey             = onKey,
+                 offMenuText       = offMenuText,
+                 offKey            = offKey,
+                 globallyVisible   = globallyVisible
+        )
+        self.setState(active = alwaysActive or not globallyVisible)
+
+Trait.known_traits.append(AreaTrait)
+#
+# EOF
+#