pywargame 0.3.1__py3-none-any.whl

pywargame/cyberboard/head.py

@@ -0,0 +1,111 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . archive import Archive
+## END_IMPORT
+
+def num_version(major,minor):
+    return major * 256 + minor
+
+def readVector(ar,cls):
+    with VerboseGuard('Reading vector') as g:
+        if Features().size_size == 8:
+            n = ar.size()
+        else:
+            n                   = ar.word()
+            if n == 0xFFFF:
+                n               = ar.dword()
+                if n == 0xFFFFFFFF:
+                    n           = ar.int(64)
+        g(f'{n} elements')
+    return [cls(ar) for _ in range(n)]
+
+# ====================================================================
+class GBXHeader:
+    BOX      = 'GBOX'
+    SCENARIO = 'GSCN'
+    def __init__(self,ar,expect=BOX):
+        '''GBXHeader of file 
+
+        4 bytes format ID
+        4x1 byte format and program version
+
+        8 bytes in total 
+        '''
+        with VerboseGuard('Reading header') as g:
+            sig = ar.chr(len(expect))
+            assert sig == expect, f'Not a {expect} file: {sig}'
+
+            self._major        = ar.byte()
+            self._minor        = ar.byte()
+            self._programMajor = ar.byte()
+            self._programMinor = ar.byte()
+            self._vers         = num_version(self._major,self._minor)
+            g(f'Version {self._major}.{self._minor}')
+
+            assert self._vers >= num_version(3,0),\
+                f'{self._major}.{self._minor} format not supported'
+
+            if self._vers >= num_version(4,0):
+                g(f'Detected version 4.0 or newer, setting some features')
+                Features().id_size       = 4
+                Features().size_size     = 8
+                Features().sub_size      = 8
+                Features().square_cells  = True
+                Features().rotate_unit   = True
+                Features().piece_100     = True
+                Features().private_board = True
+                Features().roll_state    = True
+                
+                
+            
+
+
+    def __str__(self):
+        return ('Header:\n'
+                f'  Format major version:  {self._major}\n'
+                f'  Format minor version:  {self._minor}\n'
+                f'  Program major version: {self._programMajor}\n'
+                f'  Program minor version: {self._programMinor}\n')
+
+
+# --------------------------------------------------------------------
+class GBXStrings:
+    def __init__(self,ar):
+        '''Map IDs to strings'''
+        with VerboseGuard(f'Reading string mappings'):
+            strMapN = ar.size()
+            
+            self._id2str = {}
+            for _ in range(strMapN):
+                key = ar.dword()
+                val = ar.str()
+            
+                self._id2str[key] = val
+
+    def __str__(self):
+        return ('Strings:\n'+
+                '\n'.join([f'  {key:8x}: {val}'
+                           for key,val in self._id2str.items()]))
+
+# --------------------------------------------------------------------
+class GSNStrings:
+    def __init__(self,ar):
+        '''Map IDs to strings'''
+        with VerboseGuard(f'Reading string mappings'):
+            strMapN = ar.size()
+            
+            self._id2str = {}
+            for _ in range(strMapN):
+                key = ar.size()
+                val = ar.str()
+            
+                self._id2str[key] = val
+
+    def __str__(self):
+        return ('Strings:\n'+
+                '\n'.join([f'  {key:8x}: {val}'
+                           for key,val in self._id2str.items()]))
+    
+#
+# EOF
+#

pywargame/cyberboard/image.py

@@ -0,0 +1,76 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+## END_IMPORT
+
+# ====================================================================
+class GBXImage:
+    def __init__(self,ar,transparent=None,save=None):
+        '''A DIB image stored in GameBox'''
+        with VerboseGuard('Reading an image') as g:
+            size = ar.dword()
+                
+            if size & 0x80000000: # Compressed
+                from zlib import decompress
+                g(f'Read compressed image')
+                
+                size       &= 0x80000000  # Remove flag
+                compSize   =  ar.dword() # Compressed size
+                compressed =  ar.read(compSize) # Compressed
+                buffer     = decompress(compressed,bufsize=size)
+                #assert len(buffer) == size, \
+                #    f'Failed to decompress to expected {size}, ' \
+                #    f'got {len(buffer)}'
+                    
+            else:
+                buffer  = ar.read(size)
+            
+            from PIL import Image as PILImage
+            from io import BytesIO
+            from numpy import asarray, where, uint8
+            
+            img = PILImage.open(BytesIO(buffer)).convert('RGBA')
+            
+            # If transparancy is defined, clean up the image 
+            if transparent is None:
+                self._img = img
+            else:
+                g(f'Making #{transparent:06x} transparent')
+                dat         = asarray(img)
+                tr          = (transparent >> 16) & 0xFF
+                tg          = (transparent >> 8)  & 0xFF
+                tb          = (transparent >> 0)  & 0xFF
+                dat2        = dat.copy()
+                dat2[:,:,3] = (255*(dat[:,:,:3]!=[tb,tg,tr]).any(axis=2))\
+                    .astype(uint8)
+
+                #if (dat[:,:,3] == dat2[:,:,3]).all():
+                #    print(f'Transparency operation seemed to have no effect '
+                #          f'for image')
+                
+                self._img  = PILImage.fromarray(dat2)
+            
+            if save is None:
+                return
+            
+            self._img.save(save)
+
+    @classmethod
+    def b64encode(cls,img):
+        '''Encode image as a base64 data URL'''
+        from io import BytesIO
+        from base64 import b64encode
+
+        if img is None:
+            return None
+        
+        buffered = BytesIO()
+        img.save(buffered,format='PNG')
+        data = b64encode(buffered.getvalue())
+        if not isinstance(data,str):
+            data = data.decode()
+
+        return 'data:image/png;base64,'+data
+
+#
+# EOF
+#

pywargame/cyberboard/main.py

@@ -0,0 +1,47 @@
+#!/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 Extractor
+    from common    import Verbose
+## END_IMPORT
+
+    ap = ArgumentParser(description='Read the file')
+    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')
+
+    args = ap.parse_args()
+    Verbose().setVerbose(args.verbose)
+    
+    gbx = GameBox.fromFile(args.input)
+    rat = Extractor(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/mark.py

@@ -0,0 +1,102 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . base import CbManager
+## END_IMPORT
+
+# ====================================================================
+class GBXMarkDef:
+    def __init__(self,ar):
+        '''Definition of a mark'''
+        with VerboseGuard(f'Reading mark definition'):
+            self._id    = ar.iden()
+            self._flags = ar.word()
+
+    def __str__(self):
+        return f'Mark: {self._id:04x},{self._flags:04x}'
+    
+# --------------------------------------------------------------------
+class GBXMarkSet:
+    def __init__(self,ar):
+        '''Set of marks'''
+        with VerboseGuard(f'Reading mark set'):
+            self._name   = ar.str()
+            self._viz    = ar.word()
+            n            = ar.sub_size()
+            self._marks = [ar.iden() for _ in range(n)]
+
+    def __len__(self):
+        return len(self._marks)
+
+    def __str__(self):
+        return (f'{self._name}: '+','.join([str(p) for p in self._marks]))
+    
+# --------------------------------------------------------------------
+class GBXMarkManager:
+    def __init__(self,ar):
+        '''Manager of marks'''
+        with VerboseGuard(f'Reading mark manager'):
+            self._reserved     = [ar.word() for _ in range(4)] 
+            n                  = ar.iden()
+            self._marks        = [GBXMarkDef(ar) for _ in range(n)]
+            n                  = ar.sub_size()
+            self._sets         = [GBXMarkSet(ar) for _ in range(n)]
+        
+    def __len__(self):
+        return len(self._sets)
+
+    def toDict(self,tileManager,strings):
+        from math import log10, ceil
+        with VerboseGuard(f'Creating dict from mark manager'):
+            setDigits  = int(ceil(log10(len(self)+.5)))
+            markDigits = 1
+            for markSet in self._sets:
+                markDigits = max(markDigits,
+                                 int(ceil(log10(len(markSet)+.5))))
+
+            marksMap  = {}
+            setList   = []
+            ret = {'map': marksMap,
+                   'sets': setList }
+            
+            for ips, markSet in enumerate(self._sets):
+                with VerboseGuard(f'Creating dict mark set {markSet._name}'):
+                    setPrefix = f'mark_{ips:0{setDigits}d}'
+                    idList    = []
+                    setDict   = { 'description': markSet._name.strip(),
+                                  'marks':       idList }
+                    setList.append(setDict)
+                    
+                    for ipc, markID in enumerate(markSet._marks):
+                        markPrefix = f'{setPrefix}_{ipc:0{markDigits}d}'
+                        markDef    = self._marks[markID]
+                        tmpStr     = strings._id2str.get(markID|0xF0000000,'')
+                        markDesc   = tmpStr.replace('\r','').replace('\n',', ')
+                        markDict   = {}
+                        if markDesc != '':
+                            markDict['description'] = markDesc
+                        marksMap[markID] = markDict
+                        idList  .append(markID)
+                        
+                        img = tileManager.image(markDef._id)
+                    
+                        if img is None:
+                            continue
+                    
+                        sav     = f'{markPrefix}.png'
+                        markDict.update({'image':     img,
+                                         'filename':  sav })
+
+            return ret
+    
+    def __str__(self):
+        return ('Mark manager:\n'
+                +f'Reserved: {self._reserved}\n'
+                +f'# marks: {len(self._marks)}\n  '
+                +'\n  '.join([str(p) for p in self._marks])+'\n'
+                +f'# mark sets: {len(self._sets)}\n  '
+                +'\n  '.join([str(p) for p in self._sets])
+                )
+
+#
+# EOF
+#

pywargame/cyberboard/palette.py

@@ -0,0 +1,36 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . head import num_version, readVector
+## END_IMPORT
+
+class GSNPalette:
+    def __init__(self,ar):
+        with VerboseGuard('Reading palette'):
+            self._visible    = ar.word()
+            self._comboIndex = ar.dword()
+            self._topIndex   = ar.dword()
+            
+class GSNTrayPalette(GSNPalette):
+    def __init__(self,ar,vers,iden):
+        with VerboseGuard(f'Reading scenario tray palette {iden}'):
+            super(GSNTrayPalette,self).__init__(ar)
+            self._iden       = iden
+            self._listSel    = readVector(ar,lambda ar : ar.dword())
+            
+    def __str__(self):
+        return f'GSNTrayPalette: {self._comboIndex} '\
+            f'{self._topIndex} {self._listSel}\n'
+
+class GSNMarkPalette(GSNPalette):
+    def __init__(self,ar,vers):
+        with VerboseGuard(f'Reading scenario mark palette'):
+            super(GSNMarkPalette,self).__init__(ar)
+            self._listSel    = ar.dword()
+    def __str__(self):
+        return f'GSNMarkPalette: {self._comboIndex} '\
+            f'{self._topIndex} {self._listSel}\n'
+
+#
+# EOF
+#
+

pywargame/cyberboard/piece.py

@@ -0,0 +1,169 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . head   import num_version
+## END_IMPORT
+# ====================================================================
+class GBXPieceDef:
+    def __init__(self,ar):
+        '''Definition of a piece
+
+        FRONT and BACK are tile IDs
+
+        FLAGS is ...
+        '''
+        with VerboseGuard(f'Reading piece definition'):
+            if Features().piece_100:
+                n = ar.size()
+                self._ids = [ar.iden() for _ in range(n)]
+            else:
+                self._ids = [ar.word(),ar.word()]
+            self._flags = ar.word()
+
+
+    @property
+    def _front(self):
+        return self._ids[0]
+
+    @property
+    def _back(self):
+        return self._ids[1] if len(self._ids) > 1 else 0
+    
+    def __str__(self):
+        return f'Piece: {self._front:04x},{self._back:04x},{self._flags:04x}'
+    
+# --------------------------------------------------------------------
+class GBXPieceSet:
+    def __init__(self,ar):
+        '''Set of pieces'''
+        with VerboseGuard(f'Reading piece set'):
+            self._name   = ar.str()
+            n            = ar.sub_size()
+            self._pieces = [ar.iden() for _ in range(n)]
+
+    def __len__(self):
+        return len(self._pieces)
+
+    def __str__(self):
+        return (f'{self._name}: '+','.join([str(p) for p in self._pieces]))
+    
+# --------------------------------------------------------------------
+class GBXPieceManager:
+    def __init__(self,ar):
+        '''Manager of pieces'''
+        with VerboseGuard(f'Reading piece manager') as g: 
+            self._reserved     = [ar.word() for _ in range(4)]
+            g(f'Reserved are {self._reserved}')
+            n                  = ar.iden();
+            g(f'Will read {n} pieces')
+            self._pieces       = [GBXPieceDef(ar) for _ in range(n)]
+            n                  = ar.sub_size()
+            g(f'Will read {n} sets')
+            self._sets         = [GBXPieceSet(ar) for _ in range(n)]
+
+    def __len__(self):
+        return len(self._sets)
+
+    def toDict(self,tileManager,strings):
+        from math import log10, ceil
+        with VerboseGuard(f'Creating dict from piece manager') as gg:
+            gg(f'Has {len(self._sets)} and {len(self._pieces)} pieces')
+            setDigits   = int(ceil(log10(len(self)+.5)))
+            pieceDigits = 1
+            for pieceSet in self._sets:
+                pieceDigits = max(pieceDigits,
+                                  int(ceil(log10(len(pieceSet)+.5))))
+
+            cnt       = 0
+            piecesMap = {}
+            setList   = []
+            ret = {'map': piecesMap,
+                   'sets': setList }
+
+            for ips, pieceSet in enumerate(self._sets):
+                with VerboseGuard(f'Creating dict from piece set '
+                                  f'{pieceSet._name}') as g:
+                    setPrefix = f'piece_{ips:0{setDigits}d}'
+                    idList    = []
+                    setDict   = { 'description': pieceSet._name.strip(),
+                                  'pieces':      idList }
+                    setList.append(setDict)
+                    
+                    for ipc, pieceID in enumerate(pieceSet._pieces):
+                        
+                        piecePrefix = f'{setPrefix}_{ipc:0{pieceDigits}d}'
+                        pieceDef    = self._pieces[pieceID]
+                        tmpStr      = strings._id2str.get(pieceID,'')
+                        pieceDesc   = tmpStr.replace('\r','').replace('\n',', ').replace('/','\\/')
+                        pieceDict   = {}
+                        if pieceDesc != '':
+                            pieceDict['description'] = pieceDesc
+                        cnt += 1
+                        # pieceList.append(pieceDict)
+                        idList   .append(pieceID)
+                        
+                        # print(f'{pd}  => "{tr}"')
+                        for tileId,which in zip([pieceDef._front,
+                                                 pieceDef._back],
+                                                ['front',
+                                                 'back']):                    
+                            img = tileManager.image(tileId)
+                    
+                            if img is None:
+                                continue
+                    
+                            sav     = f'{piecePrefix}_{which}.png'
+                            setname = pieceSet._name.strip()\
+                                .replace('\n',' ')\
+                                .replace('\r',' ')\
+                                .replace('/','\\/')
+                            gg(f'Set name, escaped: "{setname}"')
+                            pieceDict[which] = {
+                                'image':     img,
+                                'filename':  sav,
+                                'set':       setname }
+                        piecesMap[pieceID] = pieceDict
+                        g(f'{pieceID}: {pieceDict}')
+
+            gg(f'{list(piecesMap.keys())}')
+            return ret
+    
+        
+    def __str__(self):
+        return ('Piece manager:\n'
+                +f'Reserved: {self._reserved}\n'
+                +f'# pieces: {len(self._pieces)}\n  '
+                +'\n  '.join([str(p) for p in self._pieces])+'\n'
+                +f'# piece sets: {len(self._sets)}\n  '
+                +'\n  '.join([str(p) for p in self._sets])
+                )
+
+# --------------------------------------------------------------------
+class GSNPieceEntry:
+    def __init__(self,ar,vers,i):
+        '''Manager of pieces'''
+        with VerboseGuard(f'Reading piece # {i:3d} ({vers//256}.{vers%256})'):
+            self._side   = ar.byte()
+            self._facing = ar.word()
+            self._owner  = ar.word() if vers < num_version(3,10) else ar.dword()
+
+    def __str__(self):
+        return f'Piece: {self._side}, {self._facing:3d}, {self._owner:08x}'
+    
+# --------------------------------------------------------------------
+class GSNPieceTable:
+    def __init__(self,ar,vers):
+        '''Manager of pieces'''
+        with VerboseGuard(f'Reading piece table'):
+            self._reserved     = [ar.word() for _ in range(4)] 
+            n                  = ar.word()#sub_size()
+            if Features().piece_100:
+                dummy          = ar.word();
+            self._pieces       = [GSNPieceEntry(ar,vers,i) for i in range(n)]
+            
+    def __str__(self):
+        pl = '\n    '.join([str(s) for s in self._pieces])
+        return (f'Piece table: {self._reserved} {len(self._pieces)}'
+                f'\n    {pl}\n')
+#
+# EOF
+#

pywargame/cyberboard/player.py

@@ -0,0 +1,36 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+## END_IMPORT
+
+class GSNPlayerManager:
+    def __init__(self,ar):
+        with VerboseGuard(f'Reading players mappings'):
+            self._enable  = ar.byte()
+            self._players = []
+            if self._enable:
+                n             = ar.sub_size()
+                self._players = [GSNPlayer(ar) for _ in range(n)]
+
+    def toDict(self):
+        return [p._name for p in self._players]
+
+    def __str__(self):
+        pl = '\n    '.join([str(s) for s in self._players])
+        return ('Players:\n'
+                f'  Enabled:      {self._enable}\n'
+                f'  # players:    {len(self._players)}\n    {pl}\n')
+
+class GSNPlayer:
+    def __init__(self,ar):
+        with VerboseGuard(f'Reading player'):
+            self._key  = ar.dword()
+            self._name = ar.str()
+
+
+    def __str__(self):
+        return f'Player: {self._name} (0x{self._key:08x})'
+
+#
+# EOF
+#
+