pywargame 0.3.1__py3-none-any.whl

pywargame/vassal/traits/basic.py

@@ -0,0 +1,35 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class BasicTrait(Trait):
+    ID = 'piece'
+    def __init__(self,
+                 name      = '',
+                 filename  = '',  # Can be empty
+                 gpid      = '',  # Can be empty
+                 cloneKey  = '',  # Deprecated
+                 deleteKey = ''): # Deprecated
+        '''Create a basic unit (VASSAL.counters.BasicPiece)'''
+        self.setType(cloneKey  = cloneKey,   # CLONEKEY
+                     deleteKey = deleteKey,  # DELETEKEY
+                     filename  = filename,   # IMAGE  
+                     name      = name)       # NAME
+        self.setState(map        = 'null', # MAPID (possibly 'null')
+                      x          = 0,
+                      y          = 0,
+                      gpid       = gpid,
+                      properties = 0) # PROPERTY COUNT (followed by [; KEY; VALUE]+)
+
+    def getProperties(self):
+        n = int(self._state[4])
+        return {k: v for k, v in zip(self._state[5::2],
+                                     self._state[6::2])}
+        
+Trait.known_traits.append(BasicTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/calculatedproperty.py

@@ -0,0 +1,22 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class CalculatedTrait(Trait):
+    ID = 'calcProp'
+    def __init__(self,name='',expression='',description=''):
+        '''Define a trait that calculates a property'''
+        super(CalculatedTrait,self).__init__()
+        self.setType(name        = name,
+                     expression  = expression,
+                     description = description)
+        self.setState()
+
+
+Trait.known_traits.append(CalculatedTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/cargo.py

@@ -0,0 +1,29 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+class CargoTrait(Trait):
+    ID = 'matPiece'
+    NO_MAT = 'noMat'
+
+    def __init__(self,
+                 description = '',
+                 maintainRelativeFacing = True,
+                 detectionDistanceX     = 0,
+                 detectionDistanceY     = 0,
+                 attachKey              = '',
+                 detachKey              = ''):
+        self.setType(description            = description,
+                     maintainRelativeFacing = maintainRelativeFacing,
+                     detectionDistanceX     = detectionDistanceX,
+                     detectionDistanceY     = detectionDistanceY,
+                     attachKey              = attachKey,
+                     detachKey              = detachKey)
+        self.setState(mat = CargoTrait.NO_MAT)
+
+Trait.known_traits.append(CargoTrait)
+        
+#
+# EOF
+#

pywargame/vassal/traits/click.py

@@ -0,0 +1,41 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class ClickTrait(Trait):
+    ID = 'button'
+    def __init__(self,
+                 key         = '',
+                 x           = 0,
+                 y           = 0,
+                 width       = 0,
+                 height      = 0,
+                 description = '',
+                 context     = False,
+                 whole       = True,
+                 version     = 1,
+                 points      = []):
+        '''Create a click trait (static property)'''
+        super(ClickTrait,self).__init__()
+        self.setType(key          = key,
+                     x            = x,
+                     y            = y,
+                     width        = width,
+                     height       = height,
+                     description  = description,
+                     context      = context,
+                     whole        = whole,
+                     version      = version,
+                     npoints      = len(points),
+                     points       = ';'.join([f'{p[0]};{p[1]}'
+                                              for p in points]))            
+        self.setState()
+
+
+Trait.known_traits.append(ClickTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/clone.py

@@ -0,0 +1,28 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import *
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class CloneTrait(Trait):
+    ID      = 'clone'
+    def __init__(self,
+                 command         = '',
+                 key             = '',
+                 description     = ''):
+        '''Create a clone trait (VASSAL.counter.Clone)'''
+        super().__init__()
+
+        self.setType(command         = command,          # Context menu name
+                     key             = key,              # Context menu key
+                     description     = description)     
+        self.setState(state='')
+
+        
+
+Trait.known_traits.append(CloneTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/delete.py

@@ -0,0 +1,24 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import *
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class DeleteTrait(Trait):
+    ID = 'delete'
+    def __init__(self,
+                 name   = 'Delete',
+                 key = key('D')):
+        '''Create a delete trait (VASSAL.counters.Delete)'''
+        super(DeleteTrait,self).__init__()
+        self.setType(name  = name,
+                     key   = key,
+                     dummy = '')
+        self.setState()
+
+Trait.known_traits.append(DeleteTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/deselect.py

@@ -0,0 +1,32 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class DeselectTrait(Trait):
+    ID = 'deselect'
+    THIS = 'D' # Deselect only this piece
+    ALL  = 'A' # Deselect all pieces 
+    ONLY = 'S' # Select this piece only
+    def __init__(self,
+                 command     = '',
+                 key         = '',
+                 description = '',
+                 unstack     = False,
+                 deselect    = THIS):
+        '''Create a deselect trait'''
+        super(DeselectTrait,self).__init__()
+        self.setType(command     = command,
+                     key         = key,
+                     description = description,
+                     unstack     = unstack,
+                     deselect    = deselect)
+        self.setState()
+
+
+Trait.known_traits.append(DeselectTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/dynamicproperty.py

@@ -0,0 +1,112 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+# 
+# 
+class ChangePropertyTrait(Trait):
+    DIRECT = 'P'
+    INCREMENT = 'I'
+    PROMPT = 'R'
+    def __init__(self,
+                 *commands,
+                 numeric     = False,
+                 min         = 0,
+                 max         = 100,
+                 wrap        = False):
+        '''Base class for property (piece or global) change traits.
+        
+           Encodes constraints and commands.
+        '''
+        # assert name is not None and len(name) > 0, \
+        #     'No name specified for ChangePropertyTriat'
+        super(ChangePropertyTrait,self).__init__()
+        self._constraints = self.encodeConstraints(numeric,wrap,min,max)
+        self._commands    = self.encodeCommands(commands)
+
+    def encodeConstraints(self,numeric,wrap,min,max):
+        isnum             = f'{numeric}'.lower()
+        iswrap            = f'{wrap}'.lower()
+        return f'{isnum},{min},{max},{iswrap}'
+
+    def decodeConstraints(self,constraints):
+        f = Trait.decodeKeys(constraints)
+        return f[0]=='true',f[3]=='true',int(f[1]),int(f[2])
+    
+    def encodeCommands(self,commands):
+        cmds              = []
+        for cmd in commands:
+            # print(cmd)
+            com = cmd[0] + ':' + cmd[1].replace(',',r'\,') + ':' + cmd[2]
+            if cmd[2] == self.DIRECT:
+                com += r'\,'+cmd[3].replace(',',r'\\,').replace(':',r'\:')
+            elif cmd[2] == self.INCREMENT:
+                com += r'\,'+cmd[3].replace(',',r'\\,').replace(':',r'\:')
+            cmds.append(com)
+        # print(cmds)
+        return ','.join(cmds)
+
+    def decodeCommands(self,commands):
+        cmds = Trait.decodeKeys(commands)
+        ret  = []
+        for cmd in cmds:
+            parts = Trait.decodeKeys(cmd,':')
+            # print('parts',parts)
+            if parts[-1][0] == self.DIRECT:
+                parts = parts[:-1]+Trait.decodeKeys(parts[-1],',')
+            if parts[-1][0] == self.INCREMENT:
+                parts = parts[:-1]+Trait.decodeKeys(parts[-1],',')
+            ret.append(parts)
+        # print(commands,parts)
+        return ret
+    
+    def getCommands(self):
+        return self.decodeCommands(self['commands'])
+
+    def setCommands(self,commands):
+        self['commands'] = self.encodeCommands(commands)
+        
+    def check(self):
+        assert len(self['name']) > 0,\
+            f'No name given for ChangePropertyTrait'
+        
+        
+# --------------------------------------------------------------------
+class DynamicPropertyTrait(ChangePropertyTrait):
+    ID = 'PROP'
+    def __init__(self,
+                 *commands,
+                 name        = '',
+                 value       = 0,
+                 numeric     = False,
+                 min         = 0,
+                 max         = 100,
+                 wrap        = False,
+                 description = ''):
+        '''Commands are
+
+            - menu
+            - key
+            - Type (only 'P' for now)
+            - Expression
+        '''
+        super(DynamicPropertyTrait,self).__init__(*commands,
+                                                  numeric = numeric,
+                                                  min     = min,
+                                                  max     = max,
+                                                  wrap    = wrap)
+        # print(commands,'Name',name)
+        self.setType(name        = name,
+                     constraints = self._constraints,
+                     commands    = self._commands,
+                     description = description)
+        self.setState(value=value)
+
+    
+Trait.known_traits.append(DynamicPropertyTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/globalcommand.py

@@ -0,0 +1,55 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class GlobalCommandTrait(Trait):
+    ID = 'globalkey'
+    def __init__(self,
+                 commandName   = '',
+                 key           = '', # Command received
+                 globalKey     = '', # Command to send to targets
+                 properties    = '', # Filter target on this expression
+                 ranged        = False,
+                 range         = 1,
+                 reportSingle  = True,
+                 fixedRange    = True,
+                 rangeProperty = '',
+                 description   = '',
+                 deckSelect    = '-1',
+                 target        = ''):
+        '''Create a global key command in piece.  This sends a key
+        command to near-by counters, as if invoked by a global key
+        (module window) command.
+
+        This is _different_ from GlobalHotkeyTrait in that this does
+        not invoke and actual module window global hot key, but rather
+        sends the command directly to a near-by counter (just how
+        close depends on the range or rangeProperty parameter).
+
+        The `deckSelect` select either _all_ (value -1) or specified
+        number of pieces from deck.
+        
+        (VASSAL.counters.CounterGlobalKeyCommand)
+
+        '''
+        self.setType(commandName   = commandName,
+                     key           = key,
+                     globalKey     = globalKey,
+                     properties    = properties,
+                     ranged        = ranged,
+                     range         = range,
+                     reportSingle  = reportSingle,
+                     fixedRange    = fixedRange,
+                     rangeProperty = rangeProperty,
+                     description   = description,
+                     deckSelect    = deckSelect,
+                     target        = target)
+        self.setState()
+        
+Trait.known_traits.append(GlobalCommandTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/globalhotkey.py

@@ -0,0 +1,26 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class GlobalHotkeyTrait(Trait):
+    ID = 'globalhotkey'
+    def __init__(self,
+                 name          = '', # Command received
+                 key           = '', # Command key received
+                 globalHotkey  = '', # Key to send
+                 description   = ''):
+        '''Create a global key command in piece
+        (VASSAL.counters.GlobalHotkey)'''
+        self.setType(name          = name,
+                     key           = key,
+                     globalHotkey  = globalHotkey,
+                     description   = description)
+        self.setState()
+        
+Trait.known_traits.append(GlobalHotkeyTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/globalproperty.py

@@ -0,0 +1,54 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from . dynamicproperty import ChangePropertyTrait
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class GlobalPropertyTrait(ChangePropertyTrait):
+    # The real value of CURRENT_ZONE causes problems when copying the
+    # trait, since it contains slashes.  Maybe a solition is to make
+    # it a raw string with escaped slashes?  No, that's already done
+    # below when setting the type.  However, the default in the Java
+    # code is the CURRENT_ZONE real value, so setting this to the
+    # empty string should make it be that value.
+    ID = 'setprop'
+    CURRENT_ZONE = 'Current Zone/Current Map/Module'
+    NAMED_ZONE   = 'Named Zone'
+    NAMED_MAP    = 'Named Map'
+    DIRECT       = 'P'
+    def __init__(self,
+                 *commands,
+                 name        = '',
+                 numeric     = False,
+                 min         = 0,
+                 max         = 100,
+                 wrap        = False,
+                 description = '',
+                 level       = CURRENT_ZONE,
+                 search      = ''):
+        '''Commands are
+
+            - menu
+            - key
+            - Type (only 'P' for now)
+            - Expression
+        '''
+        super(GlobalPropertyTrait,self).__init__(*commands,
+                                                 numeric = numeric,
+                                                 min     = min,
+                                                 max     = max,
+                                                 wrap    = wrap)
+        self.setType(name        = name,
+                     constraints = self._constraints,
+                     commands    = self._commands,
+                     description = description,
+                     level       = level.replace('/',r'\/'),
+                     search      = search)
+        self.setState()
+
+Trait.known_traits.append(GlobalPropertyTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/hide.py

@@ -0,0 +1,67 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+from .. base import *
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class HideTrait(Trait):
+    ID           = 'hide'
+    ANY_SIDE     = 'side:'
+    ANY_PLAYER   = 'player:'
+    SIDES        = 'sides:'
+    @classmethod
+    def encodeAccess(cls,spec):
+        if isinstance(spec,list) and len(spec) == 1:
+            spec = spec[0]
+        if isinstance(spec,str):
+            if spec == cls.ANY_SIDE: return cls.ANY_SIDE
+            if spec == cls.ANY_PLAYER: return cls.ANY_PLAYER
+            return cls.SIDES+":"+spec
+        return cls.SIDES+':'.join(spec)
+
+    @classmethod
+    def decodeAccess(cls,spec):
+        if spec.startswith(cls.ANY_SIDE):   return cls.ANY_SIDE
+        if spec.startswith(cls.ANY_PLAYER): return cls.ANY_PLAYER
+        if spec.startswith(cls.SIDES):      return spec.split(':')[1:]
+        return None
+        
+    def __init__(self,
+                 key                   = '',
+                 command               = '',
+                 bgColor               = rgb(0x0,0x0,0x0),
+                 access                = [],
+                 transparency          = 1, # between 0 and 1
+                 description           = '',
+                 disableAutoReportMove = False,
+                 state                 = 'null'):
+        '''Create a hide trait (VASSAL.counter.Hideable)'''
+
+        super().__init__()
+        spec = self.encodeAccess(access)
+        
+        self.setType(key                   = key,      # Context menu key
+                     command               = command,  # Context menu name
+                     bgColor               = bgColor,
+                     access                = spec,
+                     transparency          = transparency,
+                     description           = description,
+                     disableAutoReportMove = disableAutoReportMove)     
+        self.setState(hiddenBy = state)
+
+    def getAccess(self):
+        return self.decodeAccess(self['access'])
+
+    def setAccess(self, access = []):
+        self['access'] = self.encodeAccess(access)
+
+        
+
+        
+
+Trait.known_traits.append(HideTrait)
+
+#
+# EOF
+#

pywargame/vassal/traits/label.py

@@ -0,0 +1,76 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from .. trait import Trait
+## END_IMPORT
+
+class LabelTraitCodes:
+    TOP    = 't'
+    BOTTOM = 'b'
+    CENTER = 'c'
+    LEFT   = 'l'
+    RIGHT  = 'r'
+    PLAIN  = 0
+    BOLD   = 1
+    ITALIC = 2
+    
+# --------------------------------------------------------------------
+class LabelTrait(Trait):
+    ID     = 'label'
+    def __init__(self,
+                 label           = None,
+                 labelKey        = '',
+                 menuCommand     ='Change label',
+                 fontSize        = 10,
+                 background      = 'none',
+                 foreground      = '255,255,255',
+                 vertical        = LabelTraitCodes.TOP,
+                 verticalOff     = 0,
+                 horizontal      = LabelTraitCodes.CENTER,
+                 horizontalOff   = 0,
+                 verticalJust    = LabelTraitCodes.BOTTOM,
+                 horizontalJust  = LabelTraitCodes.CENTER,
+                 nameFormat      = '$pieceName$ ($label$)',
+                 fontFamily      = 'Dialog',
+                 fontStyle       = LabelTraitCodes.PLAIN,
+                 rotate          = 0,
+                 propertyName    = 'TextLabel',
+                 description     = '',
+                 alwaysUseFormat = False):
+        '''Create a label trait (can be edited property)
+
+        Note that rotation comes last in the operations.  That is,
+        `horizontal...` and `vertical...` must be specified as if the
+        label is not rotated, and then rotation is applied.
+
+        Negative vertical offset moves the label _up_. 
+
+        '''
+        super(LabelTrait,self).__init__()
+        if not background or background == 'none': background = ''
+        if not foreground or foreground == 'none': foreground = ''
+        self.setType(labelKey		= labelKey,
+                     menuCommand	= menuCommand,
+                     fontSize		= fontSize,
+                     background		= background,
+                     foreground		= foreground,
+                     vertical		= vertical,
+                     verticalOff	= verticalOff,
+                     horizontal		= horizontal,
+                     horizontalOff	= horizontalOff,
+                     verticalJust	= verticalJust,
+                     horizontalJust	= horizontalJust,
+                     nameFormat		= nameFormat,
+                     fontFamily		= fontFamily,
+                     fontStyle		= fontStyle,
+                     rotate		= rotate,
+                     propertyName	= propertyName,
+                     description	= description,
+                     alwaysUseFormat	= alwaysUseFormat)
+        self.setState(label = (nameFormat if label is None else label))
+
+
+Trait.known_traits.append(LabelTrait)
+
+#
+# EOF
+#