pywargame 0.3.1__py3-none-any.whl

pywargame/vassal/traits/restrictcommand.py

@@ -0,0 +1,32 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class RestrictCommandsTrait(Trait):
+    ID = 'hideCmd'
+    HIDE = 'Hide'
+    DISABLE = 'Disable'
+    def __init__(self,
+                 name          = '',
+                 hideOrDisable = HIDE,
+                 expression    = '',# Restrict when true
+                 keys          = []):
+        '''Create a layer trait (VASSAL.counter.RestrictCommands)'''
+        super(RestrictCommandsTrait,self).__init__()
+        encKeys = ','.join([k.replace(',',r'\,') for k in keys])
+        self.setType(name          = name,
+                     hideOrDisable = hideOrDisable,
+                     expression    = expression,
+                     keys          = encKeys)
+        self.setState(state='')
+    def setKeys(self,keys):
+        self['keys'] = ','.join([k.replace(',',r'\,') for k in keys])
+    
+
+Trait.known_traits.append(RestrictCommandsTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/return.py

@@ -0,0 +1,40 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import *
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class ReturnTrait(Trait):
+    ID      = 'return'
+    def __init__(self,
+                 command         = '',
+                 key             = '',
+                 deckId          = '',
+                 prompt          = '',
+                 description     = '',
+                 version         = 2,
+                 select          = False, # If true, select at run-time
+                 expression      = ''
+                 ):
+        '''Create a return trait (VASSAL.counter.ReturnToDeck)'''
+        super().__init__()
+
+        self.setType(command         = command,          # Context menu name
+                     key             = key,              # Context menu key
+                     deckId          = deckId,
+                     prompt          = prompt,
+                     description     = description,
+                     version         = version,
+                     select          = select,
+                     expression      = expression
+                     )     
+        self.setState(state='')
+
+        
+
+Trait.known_traits.append(ReturnTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/rotate.py

@@ -0,0 +1,62 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import *
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class RotateTrait(Trait):
+    ID = 'rotate'
+    def __init__(self,
+                 nangles          = 6,
+                 rotateCWKey      = key(']'),
+                 rotateCCWKey     = key('['),
+                 rotateCW         = 'Rotate CW',
+                 rotateCCW        = 'Rotate CCW',
+                 rotateFree       = 'Rotate ...',
+                 rotateFreeKey    = key(']'),
+                 rotateRndKey     = '',
+                 rotateRnd        = '',
+                 name             = 'Rotate',
+                 description      = 'Rotate piece',
+                 rotateDirectKey  = '',
+                 rotateDirect     = '',
+                 directExpression = '',
+                 directIsFacing   = True,
+                 angle            = 0):
+        '''Create a Rotate trait'''
+        super(RotateTrait,self).__init__()
+        if nangles == 1:
+            self.setType(nangles          = nangles,
+                         rotateKey        = rotateFreeKey,
+                         rotate           = rotateFree,
+                         rotateRndKey     = rotateRndKey,
+                         rotateRnd        = rotateRnd,
+                         name             = name,
+                         description      = description,
+                         rotateDirectKey  = rotateDirectKey,
+                         rotateDirect     = rotateDirect,
+                         directExpression = directExpression,
+                         directIsFacing   = directIsFacing)
+        else:
+            self.setType(nangles          = nangles,
+                         rotateCWKey      = rotateCWKey,
+                         rotateCCWKey     = rotateCCWKey,
+                         rotateCW         = rotateCW,
+                         rotateCCW        = rotateCCW,
+                         rotateRndKey     = rotateRndKey,
+                         rotateRnd        = rotateRnd,
+                         name             = name,
+                         description      = description,
+                         rotateDirectKey  = rotateDirectKey,
+                         rotateDirect     = rotateDirect,
+                         directExpression = directExpression,
+                         directIsFacing   = directIsFacing)
+            
+        self.setState(angle = int(angle) if nangles > 1 else float(angle))
+
+Trait.known_traits.append(RotateTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/sendto.py

@@ -0,0 +1,59 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import *
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class SendtoTrait(Trait):
+    ID = 'sendto'
+    LOCATION = 'L'
+    ZONE     = 'Z'
+    REGION   = 'R'
+    GRID     = 'G'
+    COUNTER  = 'A'
+    def __init__(self,
+                 mapName     = '',
+                 boardName   = '',
+                 name        = '',
+                 key         = key('E'),
+                 restoreName = 'Restore',
+                 restoreKey  = key('R'),
+                 x           = 200,# Location
+                 y           = 200,# Location
+                 xidx        = 0,  # All - extra x
+                 yidx        = 0,  # All - extra y
+                 xoff        = 1,  # All - factor on xidx
+                 yoff        = 1,  # All - factor on yidx
+                 description = '',
+                 destination = LOCATION,
+                 zone        = '',  # Zone and region - expression
+                 region      = '',  # Region - expression
+                 expression  = '',  # Counter - expression?
+                 position    = ''): # Grid - Fixed
+        '''Create a send to trait (VASSAL.counter.SendToLocation)'''
+        self.setType(name           = name,# NAME
+                     key            = key,# KEY , MODIFIER
+                     mapName        = mapName,# MAP
+                     boardName      = boardName,# BOARD
+                     x              = x,
+                     y              = y,# X ; Y
+                     restoreName    = restoreName,# BACK
+                     restoreKey     = restoreKey,# KEY , MODIFIER
+                     xidx           = xidx,
+                     yidx           = yidx,# XIDX ; YIDX
+                     xoff           = xoff,
+                     yoff           = yoff,# XOFF ; YOFF
+                     description    = description,# DESC
+                     destination    = destination,# DEST type
+                     zone           = zone,# ZONE
+                     region         = region,# REGION
+                     expression     = expression,# EXPRESSION
+                     position       = position)                   # GRIDPOS
+        self.setState(backMap = '', backX = '', backY = '')
+
+Trait.known_traits.append(SendtoTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/sheet.py

@@ -0,0 +1,129 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import *
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class SheetTrait(Trait):
+    ID             = 'propertysheet'
+    EVERY_KEY_TEXT = 'Every Keystroke'
+    APPLY_TEXT     = 'Apply Button or Enter Key'
+    CLOSE_TEXT     = 'Close Window or Enter Key'
+    EVERY_KEY      = 0
+    APPLY          = 1
+    CLOSE          = 2
+    TEXT           = 0
+    AREA           = 1
+    LABEL          = 2
+    TICKS          = 3
+    TICKS_MAX      = 4
+    TICKS_VAL      = 5
+    TICKS_BOTH     = 6
+    SPINNER        = 7
+    TYPE_DELIM     = ';'
+    DEF_DELIM      = '~'
+    STATE_DELIM    = '~'
+    LINE_DELIM     = '|'
+    VALUE_DELIM    = '/'
+
+    @classmethod 
+    def encodeState(cls,k,e):
+        type = e['type']
+        if type == cls.TEXT:    return f'{e["value"]}'
+        if type == cls.AREA:    return f'{e["value"].replace("\n",LINE_DELIM)}'
+        if type == cls.SPINNER: return f'{e["value"]}'
+        if type in [cls.TICKS,cls.TICKS_MAX,cls.TICKS_VAL,cls.TICKS_BOTH]:
+            try:
+                val = int(e["value"])
+            except:
+                val = 0
+            try:
+                max = int(e["max"])
+            except:
+                max = 0
+            return f'{val}{cls.VALUE_DELIM}{max}'
+        return ''
+
+    @classmethod
+    def encodeDefinition(cls,rows):
+        definition = cls.DEF_DELIM.join([f'{e["type"]}{k}'
+                                     for k,e in rows.items()])
+                                
+        state      = cls.STATE_DELIM.join([self.encodeState(k,e)
+                                       for k,e in rows.items()])
+        return definition, state
+
+    @classmethod
+    def decodeDefinition(cls,definitions,state):
+        tns  = definitions.split(cls.DEF_DELIM)
+        sts  = state      .split(cls.STATE_DELIM)
+        def decodeDef(d):
+            try:
+                type = int(d[0])
+            except:
+                type = cls.TEXT
+            return type, d[1:]
+        rows = {}
+        for tn, st in zip(tns,sts):
+            type, name = decodeDef(tn)
+            rows[name] = { 'type': type }
+            rows[name].update(cls.decodeState(name,type,st))
+        return rows
+
+    @classmethod 
+    def decodeState(cls,name,type,state):
+        if type == cls.TEXT:    return {'value': state}
+        if type == cls.AREA:    return {'value': state.replace('|','\n') }
+        if type == cls.SPINNER: return {'value': state}
+        if type in [cls.TICKS,
+                    cls.TICKS_MAX,
+                    cls.TICKS_VAL,
+                    cls.TICKS_BOTH]:
+            fields = state.split(VALUE_DELIM)
+            try:
+                value = int(fields[0])
+            except:
+                value = 0
+            try:
+                max = int(fields[1])
+            except:
+                max = 0
+            return {'value': value, 'max': max }
+        return {}
+    
+    def __init__(self,
+                 command         = '',
+                 commit          = EVERY_KEY,
+                 color           = ',,',
+                 key             = '',
+                 description     = '',
+                 rows            = {}):
+        '''Create a clone trait (VASSAL.counter.Clone)'''
+        super().__init__()
+        definition, state = self.encodeDefinition(rows)
+        rgbcol = color.split(',')
+        self.setType(definition      = definition,
+                     command         = command,          # Context menu name
+                     letter          = '',
+                     commit          = commit,
+                     red             = rgbcol[0],
+                     green           = rgbcol[1],
+                     blue            = rgbcol[2],
+                     key             = key,              # Context menu key
+                     description     = description)     
+        self.setState(state=state)
+        
+        
+    def getDefinitionState(self):
+        return self.decodeDefinition(self['definition'],self['state'])
+
+    def setDefinitionState(self,rows):
+        self['definition'], self['state'] = self.encodeDefinition(rows)
+    
+
+Trait.known_traits.append(SheetTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/skel.py

@@ -0,0 +1,9 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+
+#
+# EOF
+#

pywargame/vassal/traits/stack.py

@@ -0,0 +1,28 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class StackTrait(Trait):
+    ID = 'stack'
+    def __init__(self,
+                 board     = '',
+                 x         = '',  
+                 y         = '',  
+                 pieceIds  = [],
+                 layer     = -1): 
+        '''Create a stack trait in a save file'''
+        self.setType()       # NAME
+        # print('Piece IDs:',pieceIds)
+        self.setState(board      = board,
+                      x          = x,
+                      y          = y,
+                      pieceIds   = ';'.join([str(p) for p in pieceIds]),
+                      layer      = f'@@{layer}')
+        
+Trait.known_traits.append(StackTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/submenu.py

@@ -0,0 +1,27 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class SubMenuTrait(Trait):
+    ID = 'submenu'
+    def __init__(self,
+                 subMenu     = '',  # Title
+                 keys        = [],  # Keys
+                 description = ''):
+        '''Create a sub menu (VASSAL.counters.SubMenu)'''
+        self.setType(subMenu     = subMenu,   # CLONEKEY
+                     keys        = ','.join([k.replace(',',r'\,')
+                                             for k in keys]),
+                     description = description)
+        self.setState() # PROPERTY COUNT (followed by [; KEY; VALUE]+)
+    def setKeys(self,keys):
+        '''Set the keys'''
+        self['keys'] = ','.join([k.replace(',',r'\,') for k in keys])
+        
+Trait.known_traits.append(SubMenuTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/trail.py

@@ -0,0 +1,61 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import *
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class TrailTrait(Trait):
+    ID = 'footprint'
+    def __init__(self,
+                 key             = key('T'),
+                 name            = 'Movement Trail',
+                 localVisible    = False, # Start on
+                 globalVisible   = True, # Visible to all players
+                 radius          = 10,
+                 fillColor       = rgb(255,255,255),
+                 lineColor       = rgb(0,0,0),
+                 activeOpacity   = 100,
+                 inactiveOpacity = 50,
+                 edgesBuffer     = 20,
+                 displayBuffer   = 30,
+                 lineWidth       = 5,
+                 turnOn          = key(NONE,0)+',wgTrailsOn',
+                 turnOff         = key(NONE,0)+',wgTrailsOff',
+                 reset           = '',
+                 description     = 'Enable or disable movement trail'):        
+        ''' Create a movement trail trait ( VASSAL.counters.Footprint)'''
+        super(TrailTrait,self).__init__()
+        lw = (lineWidth
+              if isinstance(lineWidth,str) and lineWidth.startswith('{') else
+              int(lineWidth))
+        ra = (radius
+              if isinstance(radius,str) and radius.startswith('{') else
+              int(radius))
+        
+        self.setType(key               = key,# ENABLE KEY
+                     name              = name,# MENU 
+                     localVisible      = localVisible,# LOCAL VISABLE
+                     globalVisible     = globalVisible,# GLOBAL VISABLE
+                     radius            = ra,# RADIUS
+                     fillColor         = fillColor,# FILL COLOR
+                     lineColor         = lineColor,# LINE COLOR 
+                     activeOpacity     = activeOpacity,# ACTIVE OPACITY
+                     inactiveOpacity   = inactiveOpacity,# INACTIVE OPACITY
+                     edgesBuffer       = edgesBuffer,# EDGES BUFFER
+                     displayBuffer     = displayBuffer,# DISPLAY BUFFER
+                     lineWidth         = lw,# LINE WIDTH 
+                     turnOn            = turnOn,# TURN ON KEY
+                     turnOff           = turnOff,# TURN OFF KEY
+                     reset             = reset,# RESET KEY
+                     description       = description)       # DESC
+        self.setState(isGlobal  = False,
+                      map       = '',
+                      points    = 0,     # POINTS (followed by [; [X,Y]*]
+                      init      = False) 
+
+Trait.known_traits.append(TrailTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/trigger.py

@@ -0,0 +1,72 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import *
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class TriggerTrait(Trait):
+    ID      = 'macro'
+    WHILE   = 'while'
+    UNTIL   = 'until'
+    COUNTED = 'counted' # - Always one "do ... while"
+    def __init__(self,
+                 name            = '',
+                 command         = '', # Context menu name
+                 key             = '', # Context menu key
+                 property        = '', # Enable/Disable
+                 watchKeys       = [],
+                 actionKeys      = [], # What to do
+                 loop            = False,
+                 preLoop         = '', # Key
+                 postLoop        = '', # Key
+                 loopType        = COUNTED, # Loop type
+                 whileExpression = '',
+                 untilExpression = '',
+                 count           = 0,
+                 index           = False,
+                 indexProperty   = '',
+                 indexStart      = '',
+                 indexStep       = ''):
+        '''Create a layer trait (VASSAL.counter.Trigger)'''
+        super(TriggerTrait,self).__init__()
+        encWKeys = Trait.encodeKeys(watchKeys, ',')
+        encAKeys = Trait.encodeKeys(actionKeys,',')
+        self.setType(name            = name,            
+                     command         = command,          # Context menu name
+                     key             = key,              # Context menu key
+                     property        = property,         # Enable/Disable
+                     watchKeys       = encWKeys,       
+                     actionKeys      = encAKeys,         # What to do
+                     loop            = loop,            
+                     preLoop         = preLoop,          # Key
+                     postLoop        = postLoop,         # Key
+                     loopType        = loopType,         # Loop type
+                     whileExpression = whileExpression, 
+                     untilExpression = untilExpression, 
+                     count           = count,           
+                     index           = index,           
+                     indexProperty   = indexProperty,   
+                     indexStart      = indexStart,      
+                     indexStep       = indexStep)       
+        self.setState(state='')
+
+    def getActionKeys(self):
+        return Trait.decodeKeys(self['actionKeys'],',')
+    
+    def getWatchKeys(self):
+        return Trait.decodeKeys(self['watchKeys'],',')
+    
+    def setActionKeys(self,keys):
+        self['actionKeys'] = Trait.encodeKeys(keys,',')
+        
+    def setWatchKeys(self,keys):
+        self['watchKeys'] = Trait.encodeKeys(keys,',')
+        
+        
+
+Trait.known_traits.append(TriggerTrait)
+
+#
+# EOF
+#