pywargame 0.3.1__py3-none-any.whl

pywargame/vassal/traits/layer.py

@@ -0,0 +1,105 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import *
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class LayerTrait(Trait):
+    ID = 'emb2'
+    def __init__(self,
+                 images       = [''],
+                 newNames     = None,
+                 activateName = 'Activate',
+                 activateMask = CTRL,
+                 activateChar = 'A',
+                 increaseName = 'Increase',
+                 increaseMask = CTRL,
+                 increaseChar = '[',
+                 decreaseName = '',
+                 decreaseMask = CTRL,
+                 decreaseChar  = ']',
+                 resetName    = '',
+                 resetKey     = '',
+                 resetLevel   = 1,
+                 under        = False,
+                 underXoff    = 0,
+                 underYoff    = 0,
+                 loop         = True,
+                 name         = '',
+                 description  = '',
+                 randomKey    = '',
+                 randomName   = '',
+                 follow       = False,
+                 expression   = '',
+                 first        = 1,
+                 version      = 1, # 1:new, 0:old
+                 always       = True,
+                 activateKey  = key('A'),
+                 increaseKey  = key('['),
+                 decreaseKey  = key(']'),
+                 scale        = 1.):
+        '''Create a layer trait (VASSAL.counter.Embellishment)'''
+        super(LayerTrait,self).__init__()
+        if newNames is None and images is not None:
+            newNames = ['']*len(images)
+        self.setType(
+            activateName        = activateName,
+            activateMask        = activateMask,
+            activateChar        = activateChar,
+            increaseName        = increaseName,
+            increaseMask        = increaseMask,
+            increaseChar        = increaseChar,
+            decreaseName        = decreaseName,
+            decreaseMask        = decreaseMask,
+            decreaseChar        = decreaseChar,
+            resetName           = resetName,
+            resetKey            = resetKey,
+            resetLevel          = resetLevel,
+            under               = under,
+            underXoff           = underXoff,
+            underYoff           = underYoff,
+            images              = ','.join(images),
+            newNames            = ','.join(newNames),
+            loop                = loop,
+            name                = name,
+            randomKey           = randomKey,
+            randomName          = randomName,
+            follow              = follow,
+            expression          = expression,
+            first               = first,
+            version             = version,
+            always              = always,
+            activateKey         = activateKey,
+            increaseKey         = increaseKey,
+            decreaseKey         = decreaseKey,
+            description         = description,
+            scale               = scale)
+        self.setState(level=1)
+
+    def getImages(self):
+        return self['images'].split(',')
+
+    def setImages(self,*images):
+        self['images'] = ','.join(images)
+        
+    def getNames(self):
+        return self['newNames'].split(',')
+
+    def setNames(self,*names):
+        images   = self.getImages()
+        newNames = ','.join(names+['']*(len(images)-len(names)))
+        self['newNames'] = newNames
+
+    def getLevel(self):
+        return self['level']
+
+    def setLevel(self,level):
+        self['level'] = level
+                            
+
+Trait.known_traits.append(LayerTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/mark.py

@@ -0,0 +1,20 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class MarkTrait(Trait):
+    ID = 'mark'
+    def __init__(self,name='',value=''):
+        '''Create a mark trait (static property)'''
+        super(MarkTrait,self).__init__()
+        self.setType(name = name)
+        self.setState(value = value)
+
+
+Trait.known_traits.append(MarkTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/mask.py

@@ -0,0 +1,85 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+# Inset
+# obs;88,130;ag_hide_1.png;Reveal;I;?;sides:Argentine;Peek;;true;;
+# obs;88,130;ag_hide_1.png;Reveal;I;?;side:Argentine;;;true;;
+#
+# Peek
+# obs;88,130;ag_hide_1.png;Reveal;P89,130;?;sides:Argentine;Peek;;true;;
+#
+# Image
+#
+class MaskTrait(Trait):
+    ID = 'obs'
+    INSET = 'I'
+    BACKGROUND = 'B'
+    PEEK = 'P'
+    IMAGE = 'G'
+    INSET2 = '2'
+    PLAYER = 'player:'
+    SIDE = 'side:'
+    SIDES = 'sides:'
+    def __init__(self,
+                 keyCommand   = '',
+                 imageName    = '',
+                 hideCommand  = '',
+                 displayStyle = '',
+                 peekKey      = '',
+                 ownerImage   = '',
+                 maskedName   = '?',
+                 access       = '',#?
+                 peekCommand  = '',
+                 description  = '',
+                 autoPeek     = True,
+                 dealKey      = '',
+                 dealExpr     = ''):
+        '''Create a masking trait'''
+        super(MaskTrait,self).__init__()
+        disp = displayStyle
+        if displayStyle == self.PEEK:
+            disp += peekKey
+        elif displayStyle == self.IMAGE:
+            disp += ownerImage
+            
+        acc = self.PLAYER
+        if isinstance(access,list):
+            acc = self.SIDES + ':'.join(access)
+        elif access.startswith('player'):
+            acc = self.PLAYER
+        elif access.startswith('side'):
+            acc = self.SIDE
+                
+        self.setType(keyCommand   = keyCommand,
+                     imageImage   = imageName,
+                     hideCommand  = hideCommand,
+                     displayStyle = disp,
+                     maskedName   = maskedName,
+                     access       = acc, # ?
+                     peekCommand  = peekCommand,
+                     description  = description,
+                     autoPeek     = autoPeek,
+                     dealKey      = dealKey,
+                     dealExpr     = dealExpr)
+        self.setState(value='null')
+
+    @classmethod
+    def peekDisplay(cls,key):#Encoded key
+        return cls.PEEK + key
+    
+    @classmethod
+    def peekImage(cls,ownerImage):
+        return cls.IMAGE + ownerImage
+
+    @classmethod
+    def sides(cls,*names):
+        return cls.SIDES+':'.join(names)
+
+Trait.known_traits.append(MaskTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/mat.py

@@ -0,0 +1,26 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+
+class MatTrait(Trait):
+    ID = 'mat'
+
+    def __init__(self,
+                 name = 'Mat',
+                 description = ''):
+        self.setType(name        = name,
+                     description = description)
+        self.setState(content='0')
+
+    def setContent(self,*args):
+        # Not sure this is correct 
+        self.setState(content=str(len(args))+';'+';'.joint(args))
+
+
+Trait.known_traits.append(MatTrait)
+	        
+#
+# EOF
+#

pywargame/vassal/traits/moved.py

@@ -0,0 +1,35 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import *
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class MovedTrait(Trait):
+    ID = 'markmoved'
+    def __init__(self,
+                 image      = 'moved.gif',
+                 xoff       = 36,
+                 yoff       = -38,
+                 name       = 'Mark moved',
+                 key        = key('M'),
+                 dummy      = ''  # Description
+                 # ignoreSame = True
+                 ):
+        '''Create a moved trait (VASSAL.counters.MovementMarkable)'''
+        super(MovedTrait,self).__init__()
+        self.setType(image    = image,
+                     xoff     = xoff,
+                     yoff     = yoff,
+                     name     = name,
+                     key      = key,
+                     dummy    = dummy, # Description
+                     # ignoreSame = ignoreSame
+                     )
+        self.setState(moved = False)
+
+Trait.known_traits.append(MovedTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/movefixed.py

@@ -0,0 +1,51 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+
+class MoveFixedTrait(Trait):
+    ID = 'translate'
+
+    def __init__(self,
+                 command        = '',   # menu command,
+                 key            = '',   # Hotkey or command
+                 dx             = 0,    # X distance (int or expr))
+                 dy             = 0,    # Y distance (int or expr))
+                 stack          = False,# Move entire stack
+                 xStepFactor    = 0,    # Factor on X offset (int or expr)
+                 yStepFactor    = 0,    # Factor on Y offset (int or expr)
+                 xStep          = 0,    # X offset (int or expr)
+                 yStep          = 0,    # Y offset (int or expr)
+                 description    = '',   # str 
+                 ):
+        '''Move a fixed distance.
+
+           x' = dx + xStepFactor * xStep 
+           y' = dy + yStepFactor * yStep 
+
+        If piece can rotate, and this is trait is given _after_ (more
+        recent in the traits list), then the piece will move according
+        to the direction faced. If given _before_ (later in the traits list),
+        then the move is relative  to the current map. 
+        
+        (VASSAL.counters.Translate)
+
+        '''
+        self.setType(command     = command,
+                     key         = key,
+                     dx          = dx,
+                     dy          = dy,
+                     stack       = stack,
+                     xStepFactor = xStepFactor,
+                     yStepFactor = yStepFactor,
+                     xStep       = xStep,
+                     yStep       = yStep,
+                     description = description)
+        self.setState()
+
+
+Trait.known_traits.append(MoveFixedTrait)
+#
+# EOF
+#

pywargame/vassal/traits/nonrect.py

@@ -0,0 +1,95 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class NonRectangleTrait(Trait):
+    ID      = 'nonRect2'
+    CLOSE   = 'c'
+    MOVETO  = 'm'
+    LINETO  = 'l'
+    CUBICTO = 'l'
+    QUADTO  = 'l'
+    def __init__(self,
+                 scale    = 1.,
+                 filename = '',
+                 path     = [],
+                 image    = None):
+        '''Create a NonRectangle trait (static property)'''
+        super(NonRectangleTrait,self).__init__()
+        l = []
+        if len(filename) > 0:
+            l.append(f'n{filename}')
+
+        if len(path) <= 0:
+            path = self.getShape(image)
+
+        if len(path) > 0:
+            # print(path)
+            l += [f'{p[0]},{int(p[1])},{int(p[2])}' if len(p) > 2 else p
+                  for p in path]
+    
+        self.setType(scale = scale,
+                     code  = ','.join(l))
+        self.setState()
+
+    @classmethod
+    def getShape(cls,buffer):
+        if buffer is None:
+            return []
+
+        from io import BytesIO
+
+        image = buffer
+        if image[:5] == b'<?xml':
+            from cairosvg import svg2png
+            image = svg2png(image)
+
+        from PIL import Image
+
+        code = []
+        with Image.open(BytesIO(image)) as img:
+            alp = img.getchannel('A') # Alpha channel
+            # Find least and largest non-transparent pixel in each row
+            rows  = []
+            w     = alp.width
+            h     = alp.height
+            bb    = alp.getbbox()
+            for r in range(bb[1],bb[3]):
+                ll, rr = bb[2], bb[0]
+                for c in range(bb[0],bb[2]):
+                    if alp.getpixel((c,r)) != 0:
+                        ll = min(c,ll)
+                        rr = max(c,rr)
+                rows += [[r-h//2,ll-w//2,rr-w//2]]
+                    
+            # Now produce the code - we start with the top line
+            code = [(cls.MOVETO,rows[0][1],rows[0][0]-1),
+                    (cls.LINETO,rows[0][2],rows[0][0]-1)]
+            
+            # Now loop  down right side of image
+            for c in rows:
+                last = code[-1]
+                if last[1] != c[2]:
+                    code += [(cls.LINETO, c[2], last[2])]
+                code += [(cls.LINETO, c[2], c[0])]
+                
+            # Now loop up left side of image
+            for c in rows[::-1]:
+                last = code[-1]
+                if last[1] != c[1]:
+                    code += [(cls.LINETO,c[1],last[2])]
+                code += [(cls.LINETO,c[1],c[0])]
+
+            # Terminate with close
+            code += [(cls.CLOSE)]
+
+        return code
+
+
+Trait.known_traits.append(NonRectangleTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/nostack.py

@@ -0,0 +1,55 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class NoStackTrait(Trait):
+    ID                    = 'immob'
+    NORMAL_SELECT         = ''
+    SHIFT_SELECT          = 'i'
+    CTRL_SELECT           = 't'
+    ALT_SELECT            = 'c'
+    NEVER_SELECT          = 'n'
+    NORMAL_BAND_SELECT    = ''
+    ALT_BAND_SELECT       = 'A'
+    ALT_SHIFT_BAND_SELECT = 'B'
+    NEVER_BAND_SELECT     = 'Z'
+    NORMAL_MOVE           = 'N'
+    SELECT_MOVE           = 'I'
+    NEVER_MOVE            = 'V'
+    NORMAL_STACK          = 'L'
+    NEVER_STACK           = 'R'
+    IGNORE_GRID           = 'g'
+    def __init__(self,
+                 select      = NORMAL_SELECT,
+                 bandSelect  = NORMAL_BAND_SELECT,
+                 move        = NORMAL_MOVE,
+                 canStack    = False,
+                 ignoreGrid  = False,
+                 description = ''):
+        '''No stacking trait
+
+        (VASSAL.counter.Immobilized)
+        '''
+        selectionOptions = (select +
+                            (self.IGNORE_GRID if ignoreGrid else '') +
+                            bandSelect)
+        movementOptions  = move
+        stackingOptions  = self.NORMAL_STACK if canStack else self.NEVER_STACK
+                 
+        '''Create a mark trait (static property)'''
+        super(NoStackTrait,self).__init__()
+        
+        self.setType(selectionOptions = selectionOptions,
+                     movementOptions  = movementOptions,
+                     stackingOptions  = stackingOptions,
+                     description      = description)
+        self.setState()
+
+
+Trait.known_traits.append(NoStackTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/place.py

@@ -0,0 +1,104 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import *
+# from .. widget import *
+# from .. withtraits import PieceSlot
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class PlaceTrait(Trait):
+    ID      = 'placemark'
+    STACK_TOP = 0
+    STACK_BOTTOM = 1
+    ABOVE = 2
+    BELOW = 3
+
+    # How the LaTeX exporter organises the units.  Format with
+    # 0: the group
+    # 1: the piece name 
+    # SKEL_PATH = (PieceWindow.TAG +r':Counters\/'        +
+    #              TabWidget.TAG   +r':Counters\/'        +
+    #              PanelWidget.TAG +':{0}'         +r'\/'+
+    #              ListWidget.TAG  +':{0} counters'+r'\/'+
+    #              PieceSlot.TAG   +':{1}')
+    @classmethod
+    # @property
+    def SKEL_PATH(cls):
+## BEGIN_IMPORT
+        from .. widget import PieceWindow, TabWidget, PanelWidget, ListWidget
+        from .. withtraits import PieceSlot
+## END_IMPORT
+
+        return (PieceWindow.TAG +r':Counters\/'        +
+                TabWidget.TAG   +r':Counters\/'        +
+                PanelWidget.TAG +':{0}'         +r'\/'+
+                ListWidget.TAG  +':{0} counters'+r'\/'+
+                PieceSlot.TAG   +':{1}')
+    
+    def __init__(self,
+                 command         = '', # Context menu name
+                 key             = '', # Context menu key
+                 markerSpec      = '', # Full path in module
+                 markerText      = 'null', # Hard coded message
+                 xOffset         = 0,
+                 yOffset         = 0,
+                 matchRotation   = True,
+                 afterKey        = '',
+                 description     = '',
+                 gpid            = '', # Set in JAVA, but with warning
+                 placement       = ABOVE,
+                 above           = False):
+        '''Create a place marker trait (VASSAL.counter.PlaceMarker)'''
+        super(PlaceTrait,self).__init__()
+        self.setType(command         = command,          # Context menu name
+                     key             = key,              # Context menu key
+                     markerSpec      = markerSpec,
+                     markerText      = markerText,
+                     xOffset         = xOffset,
+                     yOffset         = yOffset,
+                     matchRotation   = matchRotation,
+                     afterKey        = afterKey,
+                     description     = description,
+                     gpid            = gpid,
+                     placement       = placement,
+                     above           = above)
+        self.setState()
+
+Trait.known_traits.append(PlaceTrait)
+
+# --------------------------------------------------------------------
+class ReplaceTrait(PlaceTrait):
+    ID = 'replace'
+    def __init__(self,
+                 command         = '', # Context menu name
+                 key             = '', # Context menu key
+                 markerSpec      = '', # Full path in module
+                 markerText      = 'null', # Hard message
+                 xOffset         = 0,
+                 yOffset         = 0,
+                 matchRotation   = True,
+                 afterKey        = '',
+                 description     = '',
+                 gpid            = '', # Set in JAVA
+                 placement       = PlaceTrait.ABOVE,
+                 above           = False):
+        super(ReplaceTrait,self).__init__(command         = command, 
+                                          key             = key,  
+                                          markerSpec      = markerSpec,
+                                          markerText      = markerText,
+                                          xOffset         = xOffset,
+                                          yOffset         = yOffset,
+                                          matchRotation   = matchRotation,
+                                          afterKey        = afterKey,
+                                          description     = description,
+                                          gpid            = gpid,
+                                          placement       = placement,
+                                          above           = above)
+    
+
+Trait.known_traits.append(ReplaceTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/prototype.py

@@ -0,0 +1,20 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class PrototypeTrait(Trait):
+    ID = 'prototype'
+    def __init__(self,name=''):
+        '''Create a prototype trait (VASSAL.counter.UsePrototype)'''
+        super(PrototypeTrait,self).__init__()
+        self.setType(name = name)
+        self.setState(ignored = '')
+
+
+Trait.known_traits.append(PrototypeTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/report.py

@@ -0,0 +1,34 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class ReportTrait (Trait):
+    ID = 'report'
+    def __init__(self,
+                 *keys,
+                 nosuppress = True,
+                 description = '',
+                 report      = '$location$: $newPieceName$ $menuCommand$ *',
+                 cyclekeys   = '',
+                 cyclereps   = ''):
+        '''Create a report trait (VASSAL.counters.ReportActon)'''
+        super(ReportTrait,self).__init__()
+        esckeys = ','.join([k.replace(',',r'\,') for k in keys])
+        esccycl = ','.join([k.replace(',',r'\,') for k in cyclekeys])
+        escreps = ','.join([k.replace(',',r'\,') for k in cyclereps])
+        
+        self.setType(keys         = esckeys,
+                     report       = report,
+                     cycleKeys    = esccycl,
+                     cycleReports = escreps,
+                     description  = description,
+                     nosuppress   = nosuppress)
+        self.setState(cycle = -1)
+
+Trait.known_traits.append(ReportTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/restrictaccess.py

@@ -0,0 +1,28 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class RestrictAccessTrait(Trait):
+    ID = 'restrict'
+    def __init__(self,
+                 sides         = [],
+                 byPlayer      = False,
+                 noMovement    = True,
+                 description   = '',
+                 owner         = '',):
+        '''Create a layer trait (VASSAL.counter.Restricted)'''
+        super(RestrictAccessTrait,self).__init__()
+        encSides = ','.join(sides)
+        self.setType(sides         = encSides,
+                     byPlayer      = byPlayer,
+                     noMovement    = noMovement,
+                     description   = description)
+        self.setState(owner=owner)
+
+Trait.known_traits.append(RestrictAccessTrait)
+
+#
+# EOF
+#