pywargame 0.3.1__py3-none-any.whl

pywargame/cyberboard/extractor.py

@@ -0,0 +1,240 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+## END_IMPORT
+
+# ====================================================================
+class CbExtractor:
+    def __init__(self):
+        pass
+    
+    def save(self,filename):
+        from zipfile import ZipFile
+        from copy import deepcopy
+        
+        with VerboseGuard(f'Saving to {filename}') as g:
+            with ZipFile(filename,'w') as zfile:
+                self._save(zfile)
+
+    def saveImages(self,d,zfile):
+        with VerboseGuard(f'Saving images') as g:
+            for serial, board in d['boards'].items():
+                g(f'Saving board: {board}')
+                self.saveSVG(board,zfile)
+            
+            for piece in d['pieces']['map'].values():
+                g(f'Saving piece: {piece}')
+                for which in ['front','back']:
+                    if which not in piece:
+                        continue
+                
+                    side     = piece[which]
+                    self.savePNG(side,zfile)
+                    piece[which] = side['filename']
+            
+            for mark in d['marks']['map'].values():
+                g(f'Saving marks: {mark}')
+                self.savePNG(mark,zfile)
+            
+            for tile in d['tiles'].values():
+                g(f'Saving tile: {tile}')
+                self.savePNG(tile,zfile)
+            
+            del d['tiles']
+        
+
+    def saveSVG(self,d,zfile,removeImage=True):
+        from io import StringIO
+        
+        with VerboseGuard(f'Saving SVG') as g:
+            filename = d['filename']
+            image    = d['image']
+            
+            # stream = StringIO()
+            # image.write(stream,pretty=True)
+            g(f'Saving SVG: {image}')
+            zfile.writestr(filename,image)#stream.getvalue())
+
+            if removeImage:
+                del d['image']
+
+    def savePNG(self,d,zfile,removeImage=True):
+        with VerboseGuard(f'Saving PNG') as g:
+            filename = d['filename']
+            img      = d['image']
+        
+            with zfile.open(filename,'w') as file:
+                g(f'Save {img}')
+                img.save(file,format='PNG')
+
+            if removeImage:
+                del d['image']
+        
+    def _save(self,zfile):
+        pass 
+    
+    
+# ====================================================================
+class GBXExtractor(CbExtractor):
+    def __init__(self,gbx):
+        '''Turns gambox into a more sensible structure'''
+        super(GBXExtractor,self).__init__()
+
+        with VerboseGuard(f'Extract gamebox {gbx._info._title}') as g:
+            self._d = {
+                'title':       gbx._info._title,
+                'author':      gbx._info._author,
+                'description': gbx._info._description.replace('\r',''),
+                'major':       gbx._info._majorRevs,
+                'minor':       gbx._info._minorRevs,
+                'version':     f'{gbx._info._majorRevs}.{gbx._info._minorRevs}'
+            }
+
+            self._d['pieces'] = gbx._pieceManager.toDict(gbx._tileManager,
+                                                         gbx._strings)
+            self._d['marks']  = gbx._markManager.toDict(gbx._tileManager,
+                                                        gbx._strings)
+            self._d['boards'] = gbx._boardManager.toDict(gbx._tileManager,
+                                                         gbx._markManager,
+                                                         gbx._strings)
+            self._d['tiles']  = gbx._tileManager._toStore
+            
+            g(f'Done rationalizing {gbx._info._title}')
+
+        
+    def _save(self,zfile):
+        from pprint import pprint
+        from io import StringIO
+        from json import dumps
+        from copy import deepcopy
+        
+        with VerboseGuard(f'Saving {self._d["title"]} to {zfile.filename}')as g:
+            d = deepcopy(self._d)
+            
+            self.saveImages(d,zfile)
+            
+            zfile.writestr('info.json',dumps(d,indent=2))
+
+            g(f'Done saving')
+
+    def fromZipfile(self,zipfile,d):
+        pass 
+
+    def __str__(self):
+        from pprint import pformat
+
+        return pformat(self._d,depth=2)
+
+# ====================================================================
+class GSNExtractor(CbExtractor):
+    def __init__(self,gsn,zipfile=None):
+        '''Turns gambox into a more sensible structure'''
+        super(GSNExtractor,self).__init__()
+
+        if zipfile is not None:
+            self.fromZipfile(zipfile)
+            return
+        
+        with VerboseGuard(f'Extract scenario {gsn._info._title}') as g:
+            gbxextractor = GBXExtractor(gsn._gbx)
+            self._d = {
+                'title':       gsn._info._title,
+                'author':      gsn._info._author,
+                'description': gsn._info._description.replace('\r',''),
+                'major':       gsn._info._majorRevs,
+                'minor':       gsn._info._minorRevs,
+                'version':     f'{gsn._info._majorRevs}.{gsn._info._minorRevs}',
+                'gamebox':     gbxextractor._d}
+            self._d['players'] = gsn._playerManager.toDict()
+            self._d['trays']   = gsn._trayManager.toDict()
+            self._d['boards']  = gsn._boards.toDict(gsn._gbx._boardManager)
+            
+            
+    def _save(self,zfile):
+        from pprint import pprint
+        from io import StringIO
+        from json import dumps
+        from copy import deepcopy
+        
+        with VerboseGuard(f'Saving {self._d["title"]} to {zfile.filename}')as g:
+            d = deepcopy(self._d)
+            
+            self.saveImages(d['gamebox'],zfile)
+                
+            zfile.writestr('info.json',dumps(d,indent=2))
+
+            g(f'Done saving')
+
+    def fromZipfile(self,zipfile):
+        from json import loads
+        from PIL import Image as PILImage
+        from io import BytesIO
+        from wand.image import Image as WandImage
+        with VerboseGuard(f'Reading module from zip file') as v:
+            self._d = loads(zipfile.read('info.json').decode())
+            
+            newMap = {}
+            for pieceSID,piece in self._d['gamebox']['pieces']['map'].items():
+                pieceID = int(pieceSID)
+                if pieceID in newMap:
+                    continue
+                for which in ['front', 'back']:
+                    if which not in piece:
+                        continue
+            
+                    
+                    fn           = piece[which]
+                    v(f'Read image {fn}')
+                    bts          = BytesIO(zipfile.read(fn))
+                    img          = PILImage.open(bts)
+                    piece[which] = {'filename': fn,
+                                    'image':    img,
+                                    'size':     img.size}
+            
+                newMap[pieceID] = piece
+                
+            del self._d['gamebox']['pieces']['map']
+            self._d['gamebox']['pieces']['map'] = newMap
+            
+            newMap = {}
+            for markSID,mark in self._d['gamebox']['marks']['map'].items():
+                markID       = int(markSID)
+                if markID in newMap:
+                    continue 
+                fn             = mark['filename']
+                v(f'Read image {fn}')
+                bts            = BytesIO(zipfile.read(fn))
+                img            = PILImage.open(bts)
+                dsc            = mark.get('description',None)
+                mark['image']  = img
+                mark['size']   = img.size
+                newMap[markID] = mark
+                
+            del self._d['gamebox']['marks']['map']
+            self._d['gamebox']['marks']['map'] = newMap
+            
+            newMap = {}
+            for boardSID,board in self._d['gamebox']['boards'].items():
+                boardID  = int(boardSID)
+                if boardID in newMap:
+                    continue
+                filename        = board['filename']
+                v(f'Read file {filename}')
+                content         = zipfile.read(filename)
+                img             = WandImage(blob=content)
+                board['image']  = content.decode()
+                board['size']   = img.size 
+                newMap[boardID] = board
+            
+            # del self._d['gamebox']['boards']
+            # self._d['gamebox']['boards'] = newMap
+
+        # print(self)
+        
+    def __str__(self):
+        from pprint import pformat
+
+        return pformat(self._d)#,depth=5)
+    
+#
+# EOF
+#

pywargame/cyberboard/features.py

@@ -0,0 +1,17 @@
+# --------------------------------------------------------------------
+## BEGIN_IMPORT
+from common.singleton import Singleton
+## END_IMPORT
+
+class Features(metaclass=Singleton):
+    def __init__(self):
+        self.bmp_zlib      = False # wxBMPHandler + Zlib
+        self.id_size       = 2     # Size of IDs in bytes (1, 2 or 4)
+        self.size_size     = 4     # Size of sizes in bytes (4 or 8)
+        self.sub_size      = 2     # Size of sub-sizes in bytes (4 or 8)
+        self.square_cells  = False # Geomorphic boards, square cells
+        self.rotate_unit   = False # Geomorphic boards, rotated unit board
+        self.piece_100     = False # Pieces w/<= 100 sides
+        self.private_board = False #
+        self.roll_state    = False # serialize roll state
+        self.little_endian = True

pywargame/cyberboard/gamebox.py

@@ -0,0 +1,81 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . head import *
+from . tile import GBXTileManager
+from . piece import GBXPieceManager
+from . mark import GBXMarkManager
+from . board import GBXBoardManager
+from . archive import Archive
+from . features import Features
+## END_IMPORT
+
+# --------------------------------------------------------------------
+class GBXInfo:
+    def __init__(self,ar):
+        '''GameBox information'''
+        with VerboseGuard('Reading information') as g:
+            self._bitsPerPixel = ar.word()   # 2 -> 2
+            self._majorRevs    = ar.dword()  # 4 -> 6
+            self._minorRevs    = ar.dword()  # 4 -> 10
+            self._gameID       = ar.dword()  # 4 -> 14
+            self._boxID        = ar.read(16) # 16 -> 30
+            self._author       = ar.str()    # X  -> 30+X
+            self._title        = ar.str()    # Y  -> 30+X+Y
+            self._description  = ar.str()    # Z  -> 30+X+Y+Z
+            self._password     = ar.read(16) # 16 -> 46+X+Y+Z
+            self._stickyDraw   = ar.word()   # 2  -> 48+X+Y+Z
+            self._compression  = ar.word()   # 2  -> 50+X+Y+Z
+            self._reserved     = [ar.word() for _ in range(4)] # 4x2 -> 58+X+Y+Z
+            g(f'GameBox is {self._title} by {self._author} (password: {self._password})')
+        
+    def __str__(self):
+        return ('Information:\n'
+                f'  Bits/pixel:         {self._bitsPerPixel}\n'
+                f'  Major revision:     {self._majorRevs}\n'
+                f'  Minor revision:     {self._minorRevs}\n'
+                f'  Game ID:            {self._gameID}\n'
+                f'  Box ID:             {self._boxID}\n'
+                f'  Author:             {self._author}\n'
+                f'  Title:              {self._title}\n'
+                f'  Description:        {self._description}\n'
+                f'  Password:           {self._password}\n'
+                f'  Sticky Draw tools:  {self._stickyDraw}\n'
+                f'  Compression level:  {self._compression}\n'
+                f'  Reserved:           {self._reserved}')
+
+    
+# ====================================================================
+class GameBox:
+    def __init__(self,ar):
+        '''Container of game'''
+        with VerboseGuard(f'Reading gamebox'):
+            self._header       = GBXHeader(ar,GBXHeader.BOX)
+            self._info         = GBXInfo(ar)
+            self._strings      = GBXStrings(ar)
+            self._tileManager  = GBXTileManager(ar)
+            self._boardManager = GBXBoardManager(ar)
+            self._pieceManager = GBXPieceManager(ar)
+            self._markManager  = GBXMarkManager(ar)
+
+        # print(self._strings)
+        # print(self._markManager)
+        
+    def __str__(self):
+        return (str(self._header)+      
+                str(self._info)+        
+                str(self._strings)+     
+                str(self._tileManager)+ 
+                str(self._boardManager)+
+                str(self._pieceManager)+
+                str(self._markManager)) 
+
+    
+    @classmethod
+    def fromFile(cls,filename):
+        with VerboseGuard(f'Read gamebox from {filename}'):
+            with Archive(filename,'rb') as ar:
+                return GameBox(ar)
+
+#
+# EOF
+#

pywargame/cyberboard/gbxexp.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+## BEGIN_IMPORTS
+from exporter    import GBXExporter
+from common      import Verbose
+from gamebox     import GameBox
+from extractor   import GBXExtractor
+## END_IMPORTS
+
+# ====================================================================
+if __name__ == '__main__':
+    from argparse import ArgumentParser, FileType
+
+    ap = ArgumentParser(description='Create draft VASSAL module')
+    ap.add_argument('gbxfile',
+                    help='The GBX file to data from',
+                    type=FileType('r'))
+    ap.add_argument('-p','--patch',
+                    help='A python script to patch generated module',
+                    type=FileType('r'))
+    ap.add_argument('-o','--output',
+                    help='Output file to write module to',
+                    type=FileType('w'),
+                    default='Draft.vmod')
+    ap.add_argument('-r','--rules',
+                    help='Rules PDF file',
+                    type=FileType('r'))
+    ap.add_argument('-T','--tutorial',
+                    help='Tutorial (v)log file',
+                    type=FileType('r'))
+    ap.add_argument('-W','--vassal-version',
+                    help='Vassal version number',
+                    type=str,
+                    default='3.6.7')
+    ap.add_argument('-V','--verbose',
+                    help='Be verbose',
+                    action='store_true')
+    ap.add_argument('-G','--visible-grids',
+                    action='store_true',
+                    help='Make grids visible in the module')
+
+
+    args = ap.parse_args()
+
+    gbxname   = args.gbxfile.name
+    vmodname  = args.output.name
+    rulesname = args.rules.name    if args.rules    is not None else None
+    tutname   = args.tutorial.name if args.tutorial is not None else None
+    args.output.close()
+    args.gbxfile.close()
+
+    patchname = args.patch.name if args.patch is not None else None
+    if args.patch is not None:
+        args.patch.close()
+
+    Verbose().setVerbose(args.verbose)
+        
+    try:
+        gamebox   = GameBox.fromFile(gbxname)
+        extractor = GBXExtractor(gamebox)
+        exporter  = GBXExporter(extractor._d,
+                                rules         = rulesname,
+                                tutorial      = tutname,
+                                visible       = args.visible_grids,
+                                vassalVersion = args.vassal_version)
+        exporter.run(vmodname,patchname)
+    except Exception as e:
+        from sys import stderr 
+        print(f'Failed to build {vmodname}: {e}',file=stderr)
+        from os import unlink
+        try:
+            unlink(vmodname)
+        except:
+            pass
+
+        raise e
+

pywargame/cyberboard/gbxext.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+#
+# CyberBoard GitHub page:
+#
+#    https://github.com/CyberBoardPBEM/cbwindows
+#
+#
+
+
+# ====================================================================
+if __name__ == '__main__':
+    from argparse import ArgumentParser, FileType
+    from pathlib import Path
+## BEGIN_IMPORT
+    from gamebox   import GameBox
+    from extractor import GBXExtractor
+    from common    import Verbose
+## END_IMPORT
+
+    ap = ArgumentParser(description='Extract information from a '
+                        'CyberBoard GameBox file and store in ZIP archive',
+                        epilog='Default output file name is input file name '
+                        'with .gbx replaced by .zip')
+    ap.add_argument('input', type=str, help='The file')
+    ap.add_argument('output',type=str, nargs='?',help='Output',default='')
+    ap.add_argument('-V','--verbose',
+                    help='Be verbose',
+                    action='store_true')
+    ap.add_argument('-D','--dump',type=str,nargs='*',default='',
+                    help='Dump content')
+    ap.add_argument('-S','--size-bytes',type=int,choices=[4,8],
+                    default=4, help='The size of size counts')
+    ap.add_argument('-I','--id-bytes',type=int,choices=[2,4],
+                    default=2, help='The size of identifiers')
+    ap.add_argument('-P','--password',action='store_true',
+                    help='Show password')
+
+    args = ap.parse_args()
+    Verbose().setVerbose(args.verbose)
+
+    Features().size_size = args.size_bytes
+    Features().id_size   = args.id_bytes
+    
+    gbx = GameBox.fromFile(args.input)
+    if args.password:
+        print(f'Password is "{gbx._info._password.decode()}"')
+        
+    rat = GBXExtractor(gbx)
+
+    out = args.output
+    if out == '':
+        p = Path(args.input)
+        out = p.stem+'.zip'
+    
+    rat.save(out)
+
+    if 'save' in args.dump:
+        print(rat)
+    if 'gbx' in args.dump:
+        print(gbx)
+
+    
+
+    

pywargame/cyberboard/gsnexp.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python
+## BEGIN_IMPORTS
+from sys import path
+path.append('..')
+from exporter    import GSNExporter
+from common      import Verbose
+from scenario    import Scenario
+from extractor   import GSNExtractor
+from head        import GBXHeader
+## END_IMPORTS
+
+# ====================================================================
+if __name__ == '__main__':
+    from argparse import ArgumentParser, FileType, \
+         RawDescriptionHelpFormatter 
+    from textwrap import wrap, dedent
+    from pathlib import Path
+
+    w = lambda s : '\n\n'.join(['\n'.join(wrap(p))
+                                for p in dedent(s).split('\n\n')])
+    e = '''
+    	   The script can only handle CyberBoard game boxes and scenarios
+           from version 3 and up.  Use CBDesign.exe and CBPlay.exe to
+           upgrade any pre-version 3 '.gbx' and '.gsn' files, respectively.
+
+           You can override the game box files searched for by passing
+           that game box file name to the option '--gamebox'.
+
+           If the script finds the wrong main map, try passing the name
+           of the main board as argument to the option '--main-board'.
+
+           If the script adds boards (maps) to the 'Charts' menu,
+           rather than as maps, pass a regular expression to match
+           these board names, as argument to the option '--map-regex'.
+    
+           Pass a Python script with the option -p to do
+           user post-processing with that script.  Use the
+           pywargame VASSAL API to do all sorts of manipulations.
+           '''
+    
+    ap = ArgumentParser(description='Create draft VASSAL module',
+                        formatter_class= RawDescriptionHelpFormatter,
+                        epilog=w(e))
+    ap.add_argument('gsnfile',
+                    help='The GSN file to data from',
+                    type=FileType('rb'))
+    ap.add_argument('-p','--patch',
+                    help='A python script to patch generated module',
+                    type=FileType('r'))
+    ap.add_argument('-o','--output',
+                    help='Output file to write module to',
+                    type=str,
+                    default='')
+    ap.add_argument('-t','--title',
+                    help='Override title',
+                    type=str,
+                    default=None)
+    ap.add_argument('-v','--version',
+                    help='Override version',
+                    type=str,
+                    default=None)
+    ap.add_argument('-r','--rules',
+                    help='Rules PDF file',
+                    type=FileType('r'))
+    ap.add_argument('-T','--tutorial',
+                    help='Tutorial (v)log file',
+                    type=FileType('r'))
+    ap.add_argument('-W','--vassal-version',
+                    help='Vassal version number',
+                    type=str,
+                    default='3.7.0')
+    ap.add_argument('-V','--verbose',
+                    help='Be verbose',
+                    action='store_true')
+    ap.add_argument('-G','--visible-grids',
+                    action='store_true',
+                    help='Make grids visible in the module')
+    ap.add_argument('-X','--gamebox',
+                    type=str,
+                    default=None,
+                    help='Override gamebox (.gbx) file')
+    ap.add_argument('-M','--main-board',
+                    type=str,
+                    default=None,
+                    help='Set the main board')
+    ap.add_argument('-R','--map-regex',
+                    type=str,
+                    default=None,
+                    help='Regular expression to match additional maps')
+    ap.add_argument('-S','--scenario',
+                    action='store_true',
+                    help='Make scenario rather than at-start placements')
+
+
+    args = ap.parse_args()
+    
+    gsnname   = args.gsnfile.name
+    zipfile   = None
+    vmodname  = args.output
+    rulesname = args.rules.name    if args.rules    is not None else None
+    tutname   = args.tutorial.name if args.tutorial is not None else None
+    # Read first 4 bytes from input to see if we're dealing with a GSN file
+    magic     = args.gsnfile.read(4)
+    args.gsnfile.close()
+    if magic != GBXHeader.SCENARIO.encode():
+        if magic[:2] == 'PK'.encode():
+            from zipfile import ZipFile
+            zipfile = ZipFile(gsnname,'r')
+    # args.output.close()
+
+    if vmodname == '':
+        p        = Path(gsnname)
+        vmodname = p.stem+'.vmod'
+    
+    patchname = args.patch.name if args.patch is not None else None
+    if args.patch is not None:
+        args.patch.close()
+
+    Verbose().setVerbose(args.verbose)
+        
+    try:
+        scenario  = None
+        if zipfile is None:
+            scenario = Scenario.fromFile(gsnname,args.gamebox)
+        extractor = GSNExtractor(scenario,zipfile)
+        exporter  = GSNExporter(extractor._d,
+                                title         = args.title,
+                                version       = args.version,
+                                rules         = rulesname,
+                                tutorial      = tutname,
+                                visible       = args.visible_grids,
+                                main_board    = args.main_board,
+                                map_regex     = args.map_regex,
+                                vassalVersion = args.vassal_version,
+                                do_scenario   = args.scenario)
+        exporter.run(vmodname,patchname)
+    except Exception as e:
+        from sys import stderr 
+        print(f'Failed to build {vmodname}: {e}',file=stderr)
+        from os import unlink
+        try:
+            unlink(vmodname)
+        except:
+            pass
+
+        raise e
+

pywargame/cyberboard/gsnext.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+#
+# CyberBoard GitHub page:
+#
+#    https://github.com/CyberBoardPBEM/cbwindows
+#
+#
+
+
+# ====================================================================
+if __name__ == '__main__':
+    from argparse import ArgumentParser, FileType
+    from pathlib import Path
+## BEGIN_IMPORT
+    from scenario  import Scenario
+    from extractor import GSNExtractor
+    from common    import Verbose
+## END_IMPORT
+
+    ap = ArgumentParser(description='Extract information from a '
+                        'CyberBoard Scenario file and store in ZIP archive',
+                        epilog='Default output file name is input file name '
+                        'with .gsn replaced by .zip')
+    ap.add_argument('input', type=str, help='The file')
+    ap.add_argument('output',type=str, nargs='?',help='Output',default='')
+    ap.add_argument('-V','--verbose',
+                    help='Be verbose',
+                    action='store_true')
+    ap.add_argument('-D','--dump',type=str,nargs='*',default='',
+                    help='Dump content')
+    ap.add_argument('-X','--gamebox',
+                    type=str,
+                    default=None,
+                    help='Override gamebox (.gbx) file')
+
+    args = ap.parse_args()
+    Verbose().setVerbose(args.verbose)
+    
+    gsn = Scenario.fromFile(args.input,args.gamebox)
+    rat = GSNExtractor(gsn)
+
+    out = args.output
+    if out == '':
+        p = Path(args.input)
+        out = p.stem+'.zip'
+    rat.save(out)
+
+    if 'save' in args.dump:
+        print(rat)
+    if 'gsn' in args.dump:
+        print(gsn)
+
+#
+# EOF
+#
+
+    
+
+