pywargame 0.3.1__py3-none-any.whl

pywargame/cyberboard/scenario.py

@@ -0,0 +1,115 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . head    import *
+from . player  import GSNPlayerManager
+from . windows import GSNWindows
+from . palette import GSNTrayPalette
+from . palette import GSNMarkPalette
+from . board   import GSNBoardManager
+from . tray    import GSNTrayManager
+from . piece   import GSNPieceTable
+from . gamebox import GameBox
+## END_IMPORT
+
+class GSNInfo:
+    def __init__(self,ar):
+        '''Scenario information'''
+        self._disableOwnerTips = ar.word()
+        self._reserved         = [ar.word() for _ in range(3)]
+        self._gameID           = ar.dword()  # 4 -> 14
+        self._majorRevs        = ar.dword()  # 4 -> 6
+        self._minorRevs        = ar.dword()  # 4 -> 10
+        self._gbxFilename      = ar.str()
+        self._scenarioID       = ar.dword()
+        self._title            = ar.str()    # Y  -> 30+X+Y
+        self._author           = ar.str()    # X  -> 30+X
+        self._description      = ar.str()    # Z  -> 30+X+Y+Z
+        self._keepBackup       = ar.word()
+        self._keepHistory      = ar.word()
+        self._verifyState      = ar.word()
+        self._verifySave       = ar.word()
+        self._showObjectTip    = ar.word()
+
+    def __str__(self):
+        return ('Information:\n'
+                f'  Disable owner tips: {self._disableOwnerTips}\n'
+                f'  Reserved:           {self._reserved}\n'
+                f'  Game ID:            {self._gameID}\n'
+                f'  Major revision:     {self._majorRevs}\n'
+                f'  Minor revision:     {self._minorRevs}\n'
+                f'  Game box filename:  {self._gbxFilename}\n'
+                f'  Scenario ID:        {self._scenarioID}\n'
+                f'  Title:              {self._title}\n'
+                f'  Author:             {self._author}\n'
+                f'  Description:        {self._description}\n'
+                f'  Keep backup:        {self._keepBackup}\n'
+                f'  Keep history:       {self._keepHistory}\n'
+                f'  Verify state:       {self._verifyState}\n'
+                f'  Verify save:        {self._verifySave}\n'
+                f'  Show object tips:   {self._showObjectTip}\n')
+                
+# ====================================================================
+class Scenario:
+    def __init__(self,ar,gbxfilename=None):
+        '''Container of game'''
+        with VerboseGuard(f'Reading scenario'):
+            self._header        = GBXHeader       (ar,GBXHeader.SCENARIO)
+            self._info          = GSNInfo         (ar)
+            self._strings       = GSNStrings      (ar)
+            self._playerManager = GSNPlayerManager(ar)
+            self._windows       = GSNWindows      (ar)
+            self._trayA         = GSNTrayPalette  (ar,self._header._vers,'A')
+            self._trayB         = GSNTrayPalette  (ar,self._header._vers,'B')
+            self._mark          = GSNMarkPalette  (ar,self._header._vers)
+            self._boards        = GSNBoardManager (ar,self._header._vers)
+            self._trayManager   = GSNTrayManager  (ar,self._header._vers)
+            self._pieceTable    = GSNPieceTable   (ar,self._header._vers)
+            # Possibly override GBX file name 
+            if gbxfilename is not None and gbxfilename != '':
+                self._info._gbxFilename = gbxfilename
+
+            self.readGameBox(ar)
+
+    def readGameBox(self,ar):
+        from pathlib import Path
+        with VerboseGuard(f'Read game box file {self._info._gbxFilename}') as v:
+            gbxname = self._info._gbxFilename
+            gbxpath = Path(gbxname)
+            
+            if not gbxpath.exists():
+                v(f'GameBox file {gbxpath} does not exist')
+                if '\\' in gbxname:
+                    gbxname = gbxname.replace('\\','/')
+                    gbxpath = Path(gbxname)
+                gbxpath = ar.path.parent / Path(gbxpath.name)
+                if not gbxpath.exists():
+                    raise RuntimeError(f'GameBox file {gbxpath} cannot be found')
+                
+            self._gbx = GameBox.fromFile(str(gbxpath))
+
+            if self._gbx._info._gameID != self._info._gameID:
+                raise RuntimeError(f'Game IDs from GBX and GSN does not match: '
+                                   f'{self._gbx._info._gameID} versus '
+                                   f'{self._header._gameID}')
+        
+    def __str__(self):
+        return (str(self._header)+      
+                str(self._info)+        
+                str(self._strings)+
+                str(self._playerManager)+
+                str(self._windows)+
+                str(self._trayA)+
+                str(self._trayB)+
+                str(self._mark)+
+                str(self._boards)+
+                str(self._trayManager)+
+                str(self._pieceTable)+
+                str(self._gbx)+
+                ''
+                )
+
+    
+    @classmethod
+    def fromFile(cls,filename,gbxfile=None):
+        with Archive(filename,'rb') as ar:
+            return Scenario(ar,gbxfile)

pywargame/cyberboard/testgrid.py

@@ -0,0 +1,156 @@
+class Geometry:
+    RECTANGLE        = 0
+    HORIZONTAL_BRICK = 1
+    VERTICAL_BRICK   = 2
+    HEXAGON          = 3
+    SIDEWAYS_HEXAGON = 4
+    STAGGER_OUT      = 0
+    STAGGER_IN       = 1
+    TYPES = {
+        RECTANGLE       : 'rectangle',
+        HORIZONTAL_BRICK: 'horizontal brick',
+        VERTICAL_BRICK  : 'vertical brick',
+        HEXAGON         : 'hexagon',
+        SIDEWAYS_HEXAGON: 'sideways hexagon'
+    }
+    STAGGERS = {
+        STAGGER_OUT: 'out',
+        STAGGER_IN:  'in'
+    }
+    SKETCHES = {
+        RECTANGLE       : r'''
+|---|---|
+|---|---|''',
+        HORIZONTAL_BRICK: r'''
+|---|---|
+  |---|''',
+        VERTICAL_BRICK  : r'''
+|--|  |
+|  |--|
+|--|  |''',
+        HEXAGON         : r''' _
+/ \
+\_/'''        ,
+        SIDEWAYS_HEXAGON: r'''/\
+||
+\/'''
+    }
+
+    def __init__(self,nrows,ncols,tpe,stagger,w,h):
+        self._nrows   = nrows
+        self._ncols   = ncols
+        self._type    = tpe
+        self._stagger = stagger
+        self._width   = w
+        self._height  = h
+        self._dx      = w
+        self._dy      = h
+
+        if self._type == self.HEXAGON:
+            self._dx = int(0.75 * self._dx)
+        elif self._type == self.SIDEWAYS_HEXAGON:
+            self._dy = int(0.75 * self._dy)
+
+    def toPixel(self,row,col):
+        x = col * self._dx
+        y = row * self._dy
+        if self._type == self.RECTANGLE: # No offset for rectangles
+            return x,y
+        elif self._type in [self.HORIZONTAL_BRICK,self.SIDEWAYS_HEXAGON]:
+            x += self._dx//2 if (row % 2) != self._stagger else 0
+        elif self._type in [self.VERTICAL_BRICK,self.HEXAGON]:
+            y += self._dy//2 if (col % 2) != self._stagger else 0
+        return x,y
+
+    def toGrid(self,x,y):
+        col = x / self._dx
+        row = y / self._dy
+        if self._type in [self.HORIZONTAL_BRICK,self.SIDEWAYS_HEXAGON]:
+            col -= .5 if (int(row) % 2) != self._stagger else 0
+        if self._type in [self.VERTICAL_BRICK,self.HEXAGON]:
+            row -= .5  if (int(col) % 2) != self._stagger else 0
+        
+        return int(row), int(col)
+
+    def boardSize(self,nrows,ncols):
+        w = ncols * self._dx
+        h = nrows * self._dy
+
+        if self._type in [2,3]:
+            h += self._dy // 2
+        if self._type in [1,4]:
+            w += self._dx // 2
+        if self._type == 3:
+            w += self._dx // 3
+        if self._type == 4:
+            h += self._dy // 3
+
+        return w+1,h+1
+
+    def test(self,stepX=None,stepY=None):
+        from numpy import linspace
+        
+        width, height = self.boardSize(self._nrows,self._ncols)
+        print(f'Test: {self._type},{self._stagger}')
+        print(f'{self._width}x{self._height} ({self._dx},{self._dy})')
+        print(f'      {self.TYPES[self._type]} {self.STAGGERS[self._stagger]}')
+        print(self.SKETCHES[self._type])
+
+        for row in range(self._nrows):
+            for col in range(self._ncols):
+                x, y   = self.toPixel(row,col)
+                cx, cy = x + self._width // 2, y + self._height // 2
+                r, c   = self.toGrid(cx,cy)
+                print(f'== {row:3d},{col:3d} -> {cx:6d},{cy:6d} -> {r:3d},{c:3d}')
+                assert r == row, f'Rows (from {row} to {r}) inconsistent'
+                assert c == col, f'Columns (from {col} to {c}) inconsistent'
+
+                if row >= 3 or col >= 3:
+                    continue 
+                for dx in linspace(-self._width/4,self._width/4,5):
+                    idx = int(dx)
+                    for dy in linspace(-self._height/4,self._height/4,5):
+                        idy = int(dy)
+                        xx = cx + idx
+                        yy = cy + idy
+                        r, c = self.toGrid(xx,yy)
+                        if r != row or c != col:
+                            print(f'{row:3d},{col:3d} -> {cx:6d}+{idx:3d}={xx:6d},{cy:6d}+{idy:3d}={yy:6d} -> {r:3d},{c:3d}')
+            
+                    
+
+
+def testit(tpe,stagger):
+    w = 100
+    h = 100
+    if tpe == 3:
+        w = 80
+        h = 68
+    elif tpe == 4:
+        w = 68
+        h = 80
+
+    geo = Geometry(5,5,tpe,stagger,w,h)
+    geo.test()
+
+
+def testall():
+    for t in [Geometry.RECTANGLE,
+              Geometry.HORIZONTAL_BRICK,
+              Geometry.VERTICAL_BRICK,
+              Geometry.HEXAGON,
+              Geometry.SIDEWAYS_HEXAGON]:
+        for s in [Geometry.STAGGER_IN,
+                  Geometry.STAGGER_OUT]:
+            testit(t,s)
+
+
+
+testall()
+    
+    
+                
+    
+        
+        
+        

pywargame/cyberboard/tile.py

@@ -0,0 +1,121 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . image import GBXImage
+from . base import CbManager
+## END_IMPORT
+
+# ====================================================================
+class GBXTileLocation:
+    def __init__(self,ar):
+        '''Where a tile can be found'''
+        with VerboseGuard('Reading tile location') as g:
+            self._sheet  = (ar.word() if not Features().size_size == 8 else
+                            ar.size())
+            self._offset = ar.word() 
+            g(f'Tile location at sheet={self._sheet} offset={self._offset}')
+            if self._sheet == 65535: self._sheet = -1
+
+    def __str__(self):
+        return f'{self._sheet:3d} @ {self._offset:6d}'
+
+        
+# --------------------------------------------------------------------
+class GBXTileDefinition:
+    def __init__(self,ar):
+        '''The definition of a tile'''
+        with VerboseGuard('Reading tile definition'):
+            self._full = GBXTileLocation(ar)
+            self._half = GBXTileLocation(ar)
+            self._fill = ar.dword()
+
+    def __str__(self):
+        return f'Full: {self._full}, Half: {self._half}, Fill: {self._fill:08x}'
+    
+        
+# --------------------------------------------------------------------
+class GBXTileSet:
+    def __init__(self,ar):
+        '''A set of tiles'''
+        with VerboseGuard('Reading tile set'):
+            self._name = ar.str()
+            n = ar.word() if Features().size_size != 8 else ar.size()
+            self._ids  = [ar.iden()
+                          for _ in range(n)]
+
+    def __str__(self):
+        return (self._name + ':' + ','.join([str(i) for i in self._ids]))
+
+    
+# --------------------------------------------------------------------
+class GBXTileSheet:
+    def __init__(self,ar,transparent):
+        '''A single image that has multiple tile images in it
+        
+        X,Y are the tile sizes
+        '''
+        with VerboseGuard('Reading tile sheet'):
+            self._x      = ar.word()
+            self._y      = ar.word()
+            hasBM        = ar.word()
+            self._img    = GBXImage(ar,transparent) if hasBM else None
+
+    def sub(self,off):
+        if self._img is None:
+            return None
+
+        return self._img._img.crop((0,off,self._x,off+self._y))
+    
+    def __str__(self):
+        bm = str(self._img) if self._img is not None else 'None'
+        return (f'c=({self._x:4d},{self._y:4d}) bitmap={bm}')
+        
+
+# --------------------------------------------------------------------
+class GBXTileManager(CbManager):
+    def __init__(self,ar):
+        '''Tile manager (including tiles)'''
+        with VerboseGuard('Reading tile manager'):
+            self._transparent = ar.dword()
+            super(GBXTileManager,self).__init__(ar)
+            
+            ts = lambda ar : GBXTileSheet(ar, self._transparent)
+            self._tiledefs    = self._readSub(ar,GBXTileDefinition,
+                                              Features().id_size)
+            self._tilesets    = self._readSub(ar,GBXTileSet)
+            self._tilesheets  = self._readSub(ar,ts)
+            self._toStore     = {} # Used in boards, not elsewhere
+
+    def image(self,tileID):
+        if tileID is None:
+            return None 
+        if tileID == 0xFFFF:
+            return None
+
+        tileDef = self._tiledefs[tileID]
+        tileSht = self._tilesheets[tileDef._full._sheet]
+        img     = tileSht.sub(tileDef._full._offset)
+        return img
+
+    def store(self,tileID):
+        filename = self._toStore.get(tileID,{}).get('filename',None)
+        if filename is None:
+            filename              = f'tile_{tileID:04d}.png'
+            self._toStore[tileID] = {
+                'filename': filename,
+                'image'   : self.image(tileID)
+            }
+
+        return filename
+        
+        
+    def __str__(self):
+        return ('Tile manager:\n'
+                 + f'  Transparent:  {self._transparent:08x}\n'
+                 + super(GBXTileManager,self).__str__()
+                 + self._strSub('tiles',self._tiledefs) + '\n'
+                 + self._strSub('tile sets',self._tilesets) + '\n'
+                 + self._strSub('tile sheets',self._tilesheets))
+
+#
+# EOF
+#

pywargame/cyberboard/tray.py

@@ -0,0 +1,68 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+from . head import num_version, readVector
+## END_IMPORT
+    
+class GSNTraySet:
+    def __init__(self,ar,vers):
+        with VerboseGuard(f'Reading tray set') as g:
+            self._name          = ar.str()
+            g(f'Tray set: {self._name}')
+            self._random        = (ar.word() if Features().piece_100 else 0)
+            self._visibleFlags  = ar.dword()
+            self._ownerMask     = (ar.word() if vers < num_version(3,10) else
+                                   ar.dword())
+            self._restrict      = ar.word()
+            self._pieces        = readVector(ar,lambda ar: ar.iden())
+
+    def __len__(self):
+        return len(self._pieces)
+
+    def toDict(self):
+        viz = self._visibleFlags & ~0xFFFF8000
+        # print(f'{self._visibleFlags:08x} -> {viz}')
+        vizStr = {0: 'all',
+                  1: 'owner',
+                  2: 'generic',
+                  3: 'none'}.get(viz,'')
+        return {'name':     self._name,
+                'visible':  vizStr,
+                'owner':    self._ownerMask,
+                'restrict': self._restrict,
+                'pieces':   self._pieces }
+    
+    def __str__(self):
+        return (f'Tray set: {self._name} '
+                f'[visible={self._visibleFlags},'
+                f'ownerMask={self._ownerMask},'
+                f'resrict={self._restrict}] '
+                f'({len(self)}): {self._pieces}')
+
+
+class GSNTrayManager:
+    def __init__(self,ar,vers,iden=''):
+        with VerboseGuard(f'Reading tray {iden} manager @ {ar.tell()}') as g:
+            self._iden     = iden
+            self._reserved = [ar.word() for _ in range(4)]
+            g(f'{self._reserved}')
+            self._dummy    = (ar.byte() if vers >= num_version(4,0) else 0)
+            self._sets     = readVector(ar, lambda ar : GSNTraySet(ar,vers))
+
+    def __len__(self):
+        return len(self._sets)
+
+    def toDict(self):
+        return [s.toDict() for s in self._sets]
+    
+    def __str__(self):
+        pl = '\n    '.join([str(s) for s in self._sets])
+        return f'TrayManager: {self._iden} ({len(self)})\n    {pl}\n'
+
+
+#
+# EOF
+#
+
+        
+            
+            

pywargame/cyberboard/windows.py

@@ -0,0 +1,41 @@
+## BEGIN_IMPORT
+from common import VerboseGuard
+## END_IMPORT
+
+class GSNWindow:
+    def __init__(self,ar):
+        with VerboseGuard('Reading window state') as g:
+            self._code   = ar.word()
+            self._user   = ar.word()
+            self._board  = ar.iden()
+            self._state  = [ar.dword() for _ in range(10)]
+            n            = ar.size()
+            g(f'Read {self._code} {self._user} {self._board} {self._state}')
+            g(f'Reading {n} bytes at {ar.tell()}')
+            self._buffer = ar.read(n)
+
+    def __str__(self):
+        return (f'code={self._code:04x} '
+                f'user={self._user:04x} '
+                f'board={self._board:04x} '
+                f'buffer={len(self._buffer)}')
+        
+class GSNWindows:
+    def __init__(self,ar):
+        with VerboseGuard(f'Reading window states') as g: 
+            self._savePositions = ar.word()
+            self._enable        = ar.byte()
+            n                   = ar.size() if self._enable else 0
+            g(f'Save position: {self._savePositions}, '
+              f'enable {self._enable} '
+              f'n={n}')
+            self._states        = [GSNWindow(ar) for _ in range(n)]
+
+    def __str__(self):
+        pl = '\n    '.join([str(s) for s in self._states])
+        return f'Windows states ({len(self._states)})\n    {pl}\n'
+    
+
+#
+# EOF
+#

pywargame/cyberboard/zeropwd.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+## BEGIN_IMPORT
+from gamebox import GBXInfo
+from head    import GBXHeader
+from archive import Archive
+## END_IMPORT
+
+nullpwd = b'\xee\n\xcbg\xbc\xdb\x92\x1a\x0c\xd2\xf1y\x83*\x96\xc9'
+
+def zeropwd(filename):
+    from pathlib import Path
+    
+    pos = None
+    with Archive(filename,'rb') as ar:
+        header       = GBXHeader(ar,GBXHeader.BOX)
+        box          = GBXInfo(ar)
+
+
+        pos = ar.tell() - 4*2 - 2 - 2 - 16
+
+    with open(filename,'rb') as file:
+        cnt = file.read()
+        old = cnt[pos:pos+16]
+
+    lcnt = list(cnt)
+    lcnt[pos:pos+16] = list(nullpwd)
+    ncnt = bytes(lcnt)
+
+    on = Path(filename)
+    on = on.with_stem(on.stem + '-new')
+    with open(on,'wb') as file:
+        file.write(ncnt)
+
+
+if __name__ == '__main__':
+    from argparse import ArgumentParser, FileType
+    ap = ArgumentParser(description='Disable password in gamebox')
+    ap.add_argument('input', type=str, help='The file')
+
+    args = ap.parse_args()
+
+    zeropwd(args.input)
+    
+    
+