pywargame 0.3.1__py3-none-any.whl

pywargame/vassal/turn.py

@@ -0,0 +1,272 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . base import *
+from . element import Element
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class TurnLevel(Element):
+    UNIQUE = ['property']
+    def __init__(self,elem,tag,node=None,**kwargs):
+        super(TurnLevel,self).__init__(elem,tag,node=node,**kwargs)
+
+    def addLevel(self,counter=None,phases=None):
+        '''Add a `Level` element to this
+
+        Parameters
+        ----------
+        kwargs : dict
+            Dictionary of attribute key-value pairs
+        
+        Returns
+        -------
+        element : Level
+            The added element
+        '''
+        if counter is None and phases is None:
+            return self
+        
+        t = TurnCounter if counter is not None else TurnList
+        o = counter     if counter is not None else phases
+
+        subcounter = o.pop('counter',None)
+        subphases  = o.pop('phases',None)
+
+        s = t(self,node=None,**o)
+
+        return s.addLevel(subcounter, subphases)
+
+    def getUp(self):
+        return self.getParent(TurnLevel)
+    def addCounter(self,**kwargs):
+        '''Add a `Counter` element to this
+
+        Parameters
+        ----------
+        kwargs : dict
+            Dictionary of attribute key-value pairs
+        
+        Returns
+        -------
+        element : Counter
+            The added element
+        '''
+        return self.add(self,TurnCounter,**kwargs)
+    def addList(self,**kwargs):
+        '''Add a `List` element to this
+
+        Parameters
+        ----------
+        kwargs : dict
+            Dictionary of attribute key-value pairs
+        
+        Returns
+        -------
+        element : List
+            The added element
+        '''
+        return self.add(self,TurnList,**kwargs)
+    def getCounter(self):
+        return self.getAllElements(TurnCounter)
+    def getList(self):
+        return self.getAllElements(TurnList)
+
+# --------------------------------------------------------------------
+class TurnTrack(TurnLevel):
+    TAG = Element.MODULE+'turn.TurnTracker'
+    UNIQUE   = ['name']
+    MAXIMUM  = 'Maximum'
+    FIXED    = 'Fixed'
+    VARIABLE = 'Variable'
+    def __init__(self,elem,node=None,
+                 name             = '',
+                 buttonText       = 'Turn',
+                 hotkey           = '',
+                 icon             = '',
+                 length           = -1,
+                 lengthStyle      = MAXIMUM,
+                 nexthotkey       = key('T',ALT),
+                 plusButtonSize   = 22,
+                 prevhotkey       = key('T',ALT_SHIFT),
+                 reportFormat     = 'Turn updated from $oldTurn$ to $newTurn$',
+                 turnButtonHeight = 22,
+                 fwdOnly          = True,
+                 turnFormat       = None,
+                 counter          = None,
+                 phases           = None):
+        levels = (counter if counter is not None else
+                  phases if phases is not None else None)
+        if levels is not None:
+            lvl = 1
+            lvls = [f'$level{lvl}$']
+            sub  = levels
+            while True:
+                sub = sub.get('counter',sub.get('phases',None))
+                if sub is None:
+                    break
+                lvl += 1
+                lvls.append(f'$level{lvl}$')
+            
+            turnFormat = ' '.join(lvls)
+        
+        if turnFormat is None:
+            turnFormat = '$level1$ $level2$ $level3$ $level4$'        
+        
+        super(TurnTrack,self).__init__(elem, self.TAG,
+                                       node             = node,
+                                       name             = name,
+                                       buttonText       = buttonText,
+                                       hotkey           = hotkey,
+                                       icon             = icon,
+                                       length           = length,
+                                       lengthStyle      = lengthStyle,
+                                       nexthotkey       = nexthotkey,
+                                       plusButtonSize   = plusButtonSize,
+                                       prevhotkey       = prevhotkey,
+                                       reportFormat     = reportFormat,
+                                       turnButtonHeight = turnButtonHeight,
+                                       turnFormat       = turnFormat)
+
+        self.addLevel(counter=counter, phases=phases)
+
+    def getGame(self):
+        return self.getParent(Game)
+    def getLists(self,asdict=True):
+        '''Get all List element(s) from this
+
+        Parameters
+        ----------
+        asdict : bool
+            If `True`, return a dictonary that maps key to `List`
+            elements.  If `False`, return a list of all List`
+            children.
+        
+        Returns
+        -------
+        children : dict or list
+            Dictionary or list of `List` children
+
+        '''
+        return self.getElementsByKey(TurnList,'property',asdict=asdict)
+    def getCounters(self,asdict=True):
+        '''Get all Counter element(s) from this
+
+        Parameters
+        ----------
+        asdict : bool
+            If `True`, return a dictonary that maps key to `Counter`
+            elements.  If `False`, return a list of all Counter`
+            children.
+
+        Returns
+        -------
+        children : dict or list
+            Dictionary or list of `Counter` children
+
+        '''
+        return self.getElementsByKey(TurnCounter,'property',asdict=asdict)
+    def addHotkey(self,**kwargs):
+        '''Add a `Hotkey` element to this
+
+        Parameters
+        ----------
+        kwargs : dict
+            Dictionary of attribute key-value pairs
+        
+        Returns
+        -------
+        element : Hotkey
+            The added element
+        '''
+        return self.add(TurnGlobalHotkey,**kwargs)
+    def getHotkeys(self,asdict=True):
+        return self.getElementsByKey(TurnGlobalHotkey,'name',asdict=asdict)
+    def encode(self):
+        ret = f'TURN{self["name"]}\t'
+        
+        return []
+
+registerElement(TurnTrack)
+
+# --------------------------------------------------------------------
+class TurnCounter(TurnLevel):
+    TAG = Element.MODULE+"turn.CounterTurnLevel"
+    def __init__(self,elem,node=None,
+                 property      = '',
+                 start         = 1,
+                 incr          = 1,
+                 loop          = False,
+                 loopLimit     = -1,
+                 turnFormat    = "$value$"):
+        super(TurnCounter,self).__init__(elem,self.TAG,node=node,
+                                         property       = property,
+                                         start          = start,
+                                         incr           = incr,
+                                         loop           = loop,
+                                         loopLimit      = loopLimit,
+                                         turnFormat     = turnFormat)
+                    
+registerElement(TurnCounter)
+
+# --------------------------------------------------------------------
+class TurnList(TurnLevel):
+    TAG = Element.MODULE+"turn.ListTurnLevel"
+    def __init__(self,elem,node=None,
+                 property      = '',
+                 names         = [],
+                 configFirst   = False,
+                 configList    = False,
+                 turnFormat    = '$value$'):
+        super(TurnList,self).\
+            __init__(elem,self.TAG,node=node,
+                     property       = property,
+                     list           = ','.join([str(p) for p in names]),
+                     configFirst    = configFirst,
+                     configList     = configList,
+                     turnFormat     = turnFormat)
+                  
+registerElement(TurnList)
+
+# --------------------------------------------------------------------
+class TurnGlobalHotkey(Element):
+    TAG = Element.MODULE+'turn.TurnGlobalHotkey'
+    UNIQUE = ['name']
+    def __init__(self,elem,
+                 node         = None,
+                 hotkey       = '',
+                 match        = '{true}',
+                 reportFormat = '',
+                 name         = ''):
+        '''Global key activated by turn change
+
+        Parameters
+        ----------
+        doc : Element
+            Parent
+        node : xml.dom.Element
+            Node to read state from
+        hotkey : str
+            What to send (global command)
+        match : str
+            When to send
+        reportFormat : str
+            What to what
+        name : str
+            A free form name
+        '''
+        super(TurnGlobalHotkey,self).__init__(elem,self.TAG,
+                                              node         = node,
+                                              hotkey       = hotkey,
+                                              match        = match,
+                                              reportFormat = reportFormat,
+                                              name         = name)
+
+    def getTurnTrack(self):
+        '''Get the turn track'''
+        return self.getParent(TurnTrack)
+
+registerElement(TurnGlobalHotkey)
+
+#
+# EOF
+#

pywargame/vassal/upgrade.py

@@ -0,0 +1,191 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . base import *
+from . element import Element
+from . command import *
+from . trait import Trait
+from . save import SaveIO
+from . vmod import VMod
+from . buildfile import BuildFile
+from . game import Game
+from . withtraits import PieceSlot
+## END_IMPORT
+
+
+class VLogUpgrader:
+    def __init__(self,
+                 vmodFileName,
+                 vlogFileName,
+                 verbose=False):
+        self._readVModFile(vmodFileName,verbose)
+        self._readVLogFile(vlogFileName,verbose)
+
+    def _readVModFile(self,vmodFileName,verbose=False):
+        with VMod(vmodFileName, 'r') as vmod:
+            self._build = BuildFile(vmod.getBuildFile())
+            self._game  = self._build.getGame()
+
+        self._vmod_pieces = {}
+        for piece in self._game.getPieces():
+            name, piece             = self._expandPiece(piece,verbose)
+            self._vmod_pieces[name] = piece
+
+    def _expandPiece(self,piece,verbose=False):
+        traits    = piece.getTraits();
+        newTraits = Trait.flatten(traits, game=self._game,verbose=verbose)
+
+        piece.setTraits(*newTraits)
+
+        name = newTraits[-1]['name']
+
+        return name, piece
+
+    def _readVLogFile(self,vlogFileName,verbose=False):
+        key, lines, sdata, mdata = SaveIO.readSave(vlogFileName,
+                                                   alsometa=True)
+
+        self._key         = key
+        self._lines       = lines
+        self._save_data   = sdata
+        self._meta_data   = mdata
+        self._vlog_pieces = {}
+        
+        for line in self._lines:
+            iden, name, piece = self._vlogPiece(line,verbose)
+            if piece is None:
+                continue
+
+            vmod_piece        = self._vmod_pieces.get(name,None)
+            if vmod_piece is None:
+                print(f'Did not find piece "{name}" in vmod')
+                vmod_piece = piece
+
+            vmod_piece.copyStates(piece)
+            self._vlog_pieces[iden] = {'name': name,
+                                       'vlog': piece,
+                                       'vmod': vmod_piece}        
+
+
+    def _vlogPiece(self,line,verbose=False):
+        from re import match
+
+        m = match(r'^\+/([0-9]+)/.*;([a-z0-9_]+)\.png.*',line)
+        if m is None:
+            return None,None,None
+
+        iden  = int(m.group(1))
+        piece = PieceSlot(None)
+        piece.setTraits(*piece.decodeAdd(line,verbose),iden=iden)
+        basic = piece.getTraits()[-1]
+        
+        return iden,basic['name'],piece
+        
+
+    def _newLine(self,line,verbose):
+        self._new_lines.append(line)
+        if verbose:
+            print(line)
+        
+    def upgrade(self,shownew=False,verbose=False):
+        self._new_lines = []
+        for line in self._lines:
+            add_line = self.newDefine(line,verbose)
+            if add_line:
+                self._newLine(add_line,shownew)
+                continue
+
+            cmd_line = self.newCommand(line,verbose)
+            if cmd_line:
+                self._newLine(cmd_line,shownew)
+                continue 
+
+            oth_line = self.other(line,verbose)
+            if oth_line:
+                self._newLine(oth_line,shownew)
+                continue
+
+            self._newLine(line,shownew)
+
+    def newCommand(self,line,verbose=False):
+        from re import match
+
+        m = match(r'LOG\s+([+MD])/([0-9]+)/([^/]+)(.*)',line)
+        if not m:
+            return None
+    
+        cmd  = m.group(1)
+        iden = int(m.group(2))
+        more = m.group(3)
+
+        if more == 'stack':
+            return None
+
+        vp = self._vlog_pieces.get(iden,None)
+        if vp is None:
+            print(f'Piece {iden} not found: "{line}"')
+            return None
+
+        if cmd == '+' or cmd == 'M':
+            return None 
+
+        # Get the code
+        code = more + m.group(4)
+
+        # Decode the states from the code into the old piece 
+        vp['vlog'].decodeStates(code,verbose)
+
+        # Get the previsous state from the new piece 
+        old = vp['vmod'].encodedStates()
+
+        # Copy states from the old piece to the new piece 
+        vp['vmod'].copyStates(vp['vlog'],verbose)
+    
+        # Get the new state code from the new piece 
+        new = vp['vmod'].encodedStates()
+
+        newline = 'LOG\t'+cmd+'/'+str(iden)+'/'+new+'/'+old+'\\\\'
+        # print('WAS',line)
+        # print('NOW',newline)
+        return newline
+
+    def newDefine(self,line,verbose):
+        from re import match
+    
+        m = match(r'\+/([0-9]+)/([^/]+).*',line)
+
+        if not m:
+            return False
+
+        iden = int(m.group(1))
+        more = m.group(2)
+        if more == 'stack':
+            return False
+
+        vp = self._vlog_pieces.get(iden,None)
+        if vp is None:
+            print(f'Piece {iden} not known')
+
+        old = vp['vlog']
+        new = vp['vmod']
+
+        old_add = old._node.childNodes[0].nodeValue;
+        new_add = new.encodeAdd(*new.getTraits(),iden=iden,verbose=verbose);
+
+        return new_add
+        
+    def other(self,line,verbose=False):
+        return None
+    
+
+    def write(self,outFileName,verbose=False):
+        SaveIO.writeSave(outFileName,
+                         key         = 0xAA,
+                         lines       = self._new_lines,
+                         savedata    = self._save_data,
+                         moduledata  = self._meta_data)
+
+        
+        
+#
+# EOF
+#