pywargame 0.3.1__py3-none-any.whl

pywargame/__init__.py

@@ -0,0 +1,2 @@
+'''Top-level of module'''
+version = '0.3.0'

pywargame/common/__init__.py

@@ -0,0 +1,3 @@
+from . singleton import Singleton
+from . verbose import Verbose
+from . verboseguard import VerboseGuard

pywargame/common/collector.py

@@ -0,0 +1,87 @@
+## BEGIN_IMPORT
+from . verboseguard import VerboseGuard
+from . verbose import Verbose
+## END_IMPORT
+
+
+class Collector:
+    def __init__(self,executable=True):
+        '''This could be done with SED, but we don't need to rely on that'''
+        self._executable = executable
+
+    def readFile(self,filename):
+        '''Reads lines from a file and returns them.
+
+        Lines fenced by with `##` are not returned.
+
+        Lines starting with `#!` are not returned
+        '''
+        with VerboseGuard(f'Reading lines from {filename}') as g:
+            ret = [f'# {"="*68}\n'
+                   f'# From {filename}\n' ]
+            with open(filename,'r') as file:
+                lines  = file.readlines()
+                nlines = len(lines)
+                lineno = 0
+            
+                g(f'{filename} has {nlines} lines')
+                while lineno < nlines:
+                    line = lines[lineno]
+                    if line.strip().startswith('##'):
+                        start   = line
+                        startno = lineno
+            
+                        while lineno < nlines:
+                            lineno += 1
+                            if lineno >= nlines:
+                                raise RuntimeError(f'At {filename}:{lineno}:'
+                                                   f' No end to {start} in '
+                                                   f'line {startno}')
+                            
+                            line   =  lines[lineno]
+                            if line.strip().startswith('##'):
+                                g(f'Skipped lines {startno} to {lineno}')
+                                break
+                        lineno += 1
+                        continue
+            
+                    if line.startswith('#!'):
+                        g(f'Skipping line {lineno}')
+                        lineno += 1
+                        continue
+            
+                    ret.append(line)
+                    lineno += 1
+            
+                return ret
+
+    def run(self,output,*filenames):
+        lines = ['#!/usr/bin/env python\n',
+                 '# Script collected from other scripts\n',
+                 '#\n']
+        lines.extend([f'#   {filename}\n' for filename in filenames])
+        lines.append('#\n')
+            
+
+        for filename in filenames:
+            lines.extend(self.readFile(filename))
+
+        lines.extend(['##\n',
+                      '# End of generated script\n'
+                      '##\n'])
+
+
+        output.writelines(lines)
+
+        if not self._executable:
+            return
+        
+        from os import chmod
+        chmod(output.name,0o755)
+
+
+#
+# EOF
+#
+
+            

pywargame/common/dicedraw.py

@@ -0,0 +1,363 @@
+# --------------------------------------------------------------------
+class DiceContext:
+    def __init__(self,draw,darker=None):
+        self._draw = draw
+        self._darker = darker
+        
+        
+
+    def __enter__(self):
+        from wand.color import Color
+        self._draw._draw.push()
+
+        if self._darker:
+            r, g, b = (self._draw._draw.fill_color.red_int8,
+                       self._draw._draw.fill_color.green_int8,
+                       self._draw._draw.fill_color.blue_int8)
+            r *= self._darker
+            g *= self._darker
+            b *= self._darker
+            #print(r,g,b)        
+            self._draw._draw.fill_color = \
+                Color(f'srgb({int(r)},{int(g)},{int(b)})')
+        
+        return self._draw
+
+    def __exit__(self,*e):
+        self._draw._draw.pop()
+
+# --------------------------------------------------------------------
+class DicePath:
+    def __init__(self,draw):
+        self._draw = draw
+
+    def __enter__(self):
+        self._draw._draw.path_start()
+        return self
+
+    def __exit__(self,*e):
+        self._draw._draw.path_finish()
+
+    def move(self,to):
+        self._draw._draw.path_move(to=(self._draw.x(to[0]),
+                                       self._draw.y(to[1])))
+        
+    def line(self,to):
+        self._draw._draw.path_line(to=(self._draw.x(to[0]),
+                                       self._draw.y(to[1])))
+
+    def arc(self,to,r,cw=True):
+        self._draw._draw.path_elliptic_arc(to=(self._draw.x(to[0]),
+                                               self._draw.y(to[1])),
+                                           radius=(self._draw.x(r),
+                                                   self._draw.y(r)),
+                                           clockwise=cw)
+        
+# --------------------------------------------------------------------
+class DiceDraw:
+    def __init__(self,width=100,height=100,fg='black',bg='white'):
+        from wand.drawing import Drawing
+        from wand.color import Color
+        
+        self._width  = width
+        self._height = height
+        self._fg     = fg if isinstance(fg,Color) else Color(fg)
+        self._bg     = bg if isinstance(bg,Color) else Color(bg)
+        self._draw   = Drawing()
+        self._size   = min(self._width,self._height)
+
+    @property
+    def size(self):
+        return self._size
+    
+    def x(self,xx):
+        return int((xx  + 0.5) * self.size)
+
+    def y(self,yy):
+        return  int((0.5 -  yy) * self.size)
+
+    def __enter__(self):
+        self._draw.stroke_width = max(1,self.size//75)
+        self._draw.stroke_color = self._fg
+        self._draw.fill_color   = self._bg
+        return self
+
+    def number(self,num,yoff=0,scale=1):
+        if num is None or num == '':
+            return
+        
+        with DiceContext(self):
+            self._draw.stroke_width   = 1
+            self._draw.stroke_color   = self._fg
+            self._draw.fill_color     = self._fg
+            self._draw.text_alignment = 'center'
+            self._draw.font_size      = scale * self.size / 2
+            self._draw.text(self.x(0),
+                            int(self.y(yoff)+self._draw.font_size//2),
+                            f'{num}')
+            
+    def image(self):
+        from wand.image import Image as WImage
+        
+        image = WImage(width=self._width,height=self._height,format='png')
+        image.alpha_channel = True
+        self._draw(image)
+        
+        off   = min(self._width,self._height) // 30
+        copy  = image.clone()
+        copy.shadow(50,off,0,0)
+        copy.negate(channel='rgb')
+        copy.composite(image,int(off/4),int(off/4))
+        
+        #copy.save(filename='d4.png')
+        return copy
+
+    def __exit__(self,*e):
+        pass 
+
+# --------------------------------------------------------------------
+class DiceDrawer:
+    def __init__(self,nsides,width,height,fg='red',bg='white'):
+        from wand.color import Color
+        self._nsides = nsides
+        self._width  = width
+        self._height = height
+        self._fg     = Color(fg if isinstance(fg,str) else f'#{fg:06x}')
+        self._bg     = Color(bg if isinstance(bg,str) else f'#{bg:06x}')
+        if self._nsides not in [4,6,8,10,12,20]:
+            raise RuntimeError(f'Unknown number of sides: {self._nsides}')
+            
+
+    def draw(self,num):
+        if self._nsides ==  4:  return self.draw_d4 (num)
+        if self._nsides ==  6:  return self.draw_d6 (num)
+        if self._nsides ==  8:  return self.draw_d8 (num)
+        if self._nsides == 10:  return self.draw_d10(num)
+        if self._nsides == 12:  return self.draw_d12(num)
+        if self._nsides == 20:  return self.draw_d20(num)
+        return None
+        
+    def draw_d4(self,num):
+        with DiceDraw(self._width,self._height,
+                      fg=self._fg,bg=self._bg) as draw:
+            with DicePath(draw) as path:
+                path.move(to=( 0.000, 0.40))
+                path.line(to=( 0.433,-0.35))
+                path.line(to=(-0.433,-0.35))
+                path.line(to=( 0.000, 0.40))
+
+            draw.number(num)
+            return draw.image()
+
+    def draw_d6(self,num):
+        with DiceDraw(self._width,self._height,
+                      fg=self._fg,bg=self._bg) as draw:
+            with DicePath(draw) as path:
+                r = 0.05
+                w = .4 - r
+                path.move(to=(    w, 0.40))
+                path.arc (to=( 0.40,    w), r=r)
+                path.line(to=( 0.40,-   w))
+                path.arc (to=(    w,-0.40), r=r)
+                path.line(to=(-   w,-0.40))
+                path.arc (to=(-0.40,-   w), r=r)
+                path.line(to=(-0.40,    w))
+                path.arc (to=(-   w, 0.40), r=r)
+                path.line(to=(    w, 0.40))
+
+            draw.number(num,yoff=.1)
+            return draw.image()
+
+    def draw_d8(self,num):
+        with DiceDraw(self._width,self._height,
+                      fg=self._fg,bg=self._bg) as draw:
+            with DiceContext(draw,darker=.9):
+                with DicePath(draw) as path:
+                    path.move(to=(0.0000,0.5000))
+                    path.line(to=(0.4330,0.2500))
+                    path.line(to=(0.4330,-0.2500))
+                    path.line(to=(0.0000,-0.5000))
+                    path.line(to=(-0.4330,-0.2500))
+                    path.line(to=(-0.4330,0.2500))
+                    path.line(to=(0.0000,0.5000))
+                        
+            with DicePath(draw) as path:
+                path.move(to=(0.0000,0.5000))
+                path.line(to=(0.4330,-0.2500))
+                path.line(to=(-0.4330,-0.2500))
+                path.line(to=(0.0000,0.5000))
+
+            draw.number(num,yoff=.1)
+            return draw.image()
+
+    def draw_d10(self,num):
+        with DiceDraw(self._width,self._height,
+                      fg=self._fg,bg=self._bg) as draw:
+            with DiceContext(draw,darker=.9):
+                with DicePath(draw) as path:
+                    path.move(to=(0.0000,0.5000))            
+                    path.line(to=(0.4750,0.1000))
+                    path.line(to=(0.4750,-0.1000))
+                    path.line(to=(0.0000,-0.5000))
+                    path.line(to=(-0.4750,-0.1000))
+                    path.line(to=(-0.4750,0.1000))
+                    path.line(to=(0.0000,0.5000))
+                    path.move(to=(0.2940,-0.1540))
+                    path.line(to=(0.4750,-0.1000))
+                    path.move(to=(-0.4750,-0.1000))
+                    path.line(to=(-0.2940,-0.1540))
+                    path.move(to=(0.0000,-0.5000))
+                    path.line(to=(0.0000,-0.3000))
+            with DicePath(draw) as path:
+                path.move(to=(0.0000,0.5000))
+                path.line(to=(0.2940,-0.1540))
+                path.line(to=(0.0000,-0.3000))
+                path.line(to=(-0.2940,-0.1540))
+                path.line(to=(0.0000,0.5000))
+
+            draw.number(num,yoff=.1)
+            return draw.image()
+
+    def draw_d12(self,num):
+        with DiceDraw(self._width,self._height,
+                      fg=self._fg,bg=self._bg) as draw:
+            with DiceContext(draw,darker=.9):
+                with DicePath(draw) as path:
+                    path.move(to=( 0.0000, 0.5000))
+                    path.line(to=( 0.2940, 0.4050))
+                    path.line(to=( 0.4750, 0.1730))
+                    path.line(to=( 0.4750,-0.1730))
+                    path.line(to=( 0.2940,-0.4050))
+                    path.line(to=( 0.0000,-0.5000))
+                    path.line(to=(-0.2940,-0.4050))
+                    path.line(to=(-0.4750,-0.1730))
+                    path.line(to=(-0.4750, 0.1730))
+                    path.line(to=(-0.2940, 0.4050))
+                    path.line(to=( 0.0000, 0.5000))
+                    path.line(to=( 0.0000, 0.3490))
+                    path.move(to=( 0.4750, 0.1730))
+                    path.line(to=( 0.3320, 0.1080))
+                    path.move(to=( 0.2940,-0.4050))
+                    path.line(to=( 0.2050,-0.2820))
+                    path.move(to=(-0.2940,-0.4050))
+                    path.line(to=(-0.2050,-0.2820))
+                    path.move(to=(-0.4750, 0.1730))
+                    path.line(to=(-0.3320, 0.1080))
+            with DicePath(draw) as path:
+                path.move(to=(0.0000,0.3490))
+                path.line(to=(0.3320,0.1080))
+                path.line(to=(0.2050,-0.2820))
+                path.line(to=(-0.2050,-0.2820))
+                path.line(to=(-0.3320,0.1080))
+                path.line(to=(0.0000,0.3490))
+                    
+
+            draw.number(num,yoff=.1)
+            return draw.image()
+            
+    def draw_d20(self,num):
+        with DiceDraw(self._width,self._height,
+                      fg=self._fg,bg=self._bg) as draw:
+            with DiceContext(draw,darker=.85):
+                with DicePath(draw) as path:
+                    path.move(to=(0.0000,0.5000))
+                    path.line(to=(0.4540,0.2620))
+                    path.line(to=(0.4540,-0.2620))
+                    path.line(to=(0.0000,-0.5000))
+                    path.line(to=(-0.4540,-0.2620))
+                    path.line(to=(-0.4540,0.2620))
+                    path.line(to=(0.0000,0.5000))            
+                    path.line(to=(0.0000,0.2920))
+            with DiceContext(draw,darker=.95):
+                with DicePath(draw) as path:
+                    path.move(to=(0.0000,0.2920))
+                    path.line(to=(0.4540,0.2620))
+                    path.line(to=(0.2530,-0.1460))
+                    path.line(to=(0.0000,-0.5000))
+                    path.line(to=(-0.2530,-0.1460))
+                    path.line(to=(-0.4540,0.2620))
+                    path.line(to=(0.0000,0.2920))
+                    path.move(to=(0.4540,-0.2620))
+                    path.line(to=(0.2530,-0.1460))
+                    path.move(to=(-0.4540,-0.2620))
+                    path.line(to=(-0.2530,-0.1460))
+            with DicePath(draw) as path:
+                path.move(to=(0.0000,0.2920))
+                path.line(to=(0.2530,-0.1460))
+                path.line(to=(-0.2530,-0.1460))
+                path.line(to=(0.0000,0.2920))
+            
+
+            draw.number(num,yoff=.07,scale=.7)
+            return draw.image()
+
+
+# --------------------------------------------------------------------
+class DiceAnimator:
+    def __init__(self,nsides,width,height,fg='red',bg='white'):
+        drawer = DiceDrawer(nsides = nsides,
+                            width  = width,
+                            height = height,
+                            fg     = fg,
+                            bg     = bg)
+        self._pool = [drawer.draw(v) for v in range(1,nsides+1)]
+            
+    def draw(self,num,n,dt=10):
+        
+        '''
+        delay : int
+            1 / 100 of a second as base delay
+        '''
+        from random     import sample
+        from wand.image import Image
+
+        if num > len(self._pool):
+            raise RuntimeError(f'Final value {num} not possible for '
+                               f'd{len(self._pool)}')
+
+        if n >= len(self._pool) - 1:
+            raise RuntimeError(f'Pre-steps {n} not possible for '
+                               f'd{len(self._pool)}')
+            
+        end   = self._pool[num-1]
+
+        # Round-about, but for debug 
+        nums  = list(range(1,len(self._pool)+1))
+        nums.remove(num)
+        pool  = sample(nums, k=n)
+        other = [self._pool[i-1] for i in pool]
+        print(num,pool)
+        
+        # More direct
+        # pool  = self._pool[:num] + self._pool[num+1:]
+        # other = sample(pool, k=n)
+        
+        faces = other + [end]
+        dang  = 360 / (len(faces))
+        img   = Image(format='gif')
+        ang   = 360
+        wait  = dt
+        for i, face in enumerate(faces):
+            ang  -= dang
+            wait += dt
+
+            with face.clone() as rotated:
+                w, h = rotated.size
+                rotated.rotate(ang, reset_coords=False)
+                rotated.crop(0,0,w,h)
+                rotated.dispose = 'previous'
+                rotated.delay   = wait # dt * (i + 1)
+                rotated.loop    = 1
+                img.sequence.append(rotated)
+
+        # Make sure we dispose of the previous image altogether
+        #img.dispose = 'previous'
+        img.coalesce()
+        #img.deconstruct()
+        
+
+        return img
+
+#
+# EOF
+#

pywargame/common/drawdice.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+
+if __name__ == '__main__':
+    from sys import path
+    
+    from argparse import ArgumentParser
+    from dicedraw import DiceDrawer
+
+    ap = ArgumentParser(description='Make a series of dice images')
+    ap.add_argument('-n','--sides', choices=[4,6,8,10,12,20],
+                    default=6, type=int,
+                    help='Number of sides')
+    ap.add_argument('-f','--foreground', type=str, default='white',
+                    help='Foreground color')
+    ap.add_argument('-b','--background', type=str, default='#333333',
+                    help='Background color')
+    ap.add_argument('-W','--width',type=int,default=75,
+                    help='Width of images')
+    ap.add_argument('-H','--height',type=int,default=75,
+                    help='Height of images')
+    ap.add_argument('-B','--base',type=str,default='d{sides}-{value}.png',
+                    help='Format of file names')
+
+    args = ap.parse_args()
+
+    dd = DiceDrawer(args.sides,
+                    args.width,
+                    args.height,
+                    fg = args.foreground,
+                    bg = args.background)
+
+    base = args.base
+
+    vals = list(range(0,args.sides) if args.sides == 10 else
+                range(1,args.sides+1))
+    for val in vals:
+        dd.draw(val).save(filename=base.format(sides=args.sides,value=val))
+
+        
+    

pywargame/common/singleton.py

@@ -0,0 +1,22 @@
+# ====================================================================
+class Singleton(type):
+    '''Meta base class for singletons'''
+    _instances = {}
+    def __call__(cls, *args, **kwargs):
+        '''Create the singleton object or returned existing
+
+        Parameters
+        ----------
+        args : tuple
+            Arguments
+        kwargs : dict
+            Keyword arguments
+        '''
+        if cls not in cls._instances:
+            cls._instances[cls] = \
+                super(Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+#
+# EOF
+#

pywargame/common/test.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+
+from verboseguard import VerboseGuard
+from verbose import Verbose
+
+def inner():
+    with VerboseGuard('Entering inner') as g:
+        g('Message from inner')
+        
+def test():
+    with VerboseGuard('Entering test'):
+        inner()
+    
+
+if __name__ == '__main__':
+    from argparse import ArgumentParser
+
+    ap = ArgumentParser('test verbose')
+    ap.add_argument('-v','--verbose',help='Be verbose',action='store_true')
+
+    args = ap.parse_args()
+
+    Verbose().setVerbose(args.verbose)
+    
+    test()

pywargame/common/verbose.py

@@ -0,0 +1,59 @@
+# --------------------------------------------------------------------
+## BEGIN_IMPORT
+from . singleton import Singleton
+## END_IMPORT
+
+class Verbose(metaclass=Singleton):
+    def __init__(self,verbose=False):
+        '''Singleton for writing message to screen, contigent on setting
+
+        Parameters
+        ----------
+        verbose : bool
+             Whether to show messages or not
+        '''
+        self._indent  = ''
+        self._verbose = verbose
+
+    def setVerbose(self,verbose):
+        '''Set whether to print or not
+
+        Parameters
+        ----------
+        verbose : bool
+             Whether to show messages or not
+        '''
+        self._verbose = verbose
+
+    @property
+    def verbose(self):
+        '''Test if this is verbose'''
+        return self._verbose
+
+    def message(self,*args,**kwargs):
+        '''Write messsage if verbose
+
+        Parameters
+        ----------
+        args : tuple
+            Arguments
+        kwargs : dict
+            Keyword arguments
+        '''        
+        if not self._verbose: return
+        if not kwargs.pop('noindent', False):
+            print(self._indent,end='')
+        print(*args,**kwargs)
+
+    def incr(self):
+        '''Increment indention'''
+        self._indent += ' '
+
+    def decr(self):
+        '''Decrement indention'''
+        if len(self._indent) > 0:
+            self._indent = self._indent[:-1]
+
+#
+# EOF
+#

pywargame/common/verboseguard.py

@@ -0,0 +1,53 @@
+# --------------------------------------------------------------------
+## BEGIN_IMPORT
+from . verbose import Verbose
+## END_IMPORT
+
+class VerboseGuard:
+    def __init__(self,*args,**kwargs):
+        '''A guard pattern that increases verbose indention
+
+        This is a context manager.  The arguments passed are used for
+        an initial message, before increasinig indention.
+
+        Parameters
+        ----------
+        args : tuple
+            Arguments
+        kwargs : dict
+            Keyword arguments
+        '''                
+        Verbose().message(*args,**kwargs)
+
+    def __bool_(self):
+        '''Test if verbose'''
+        return Verbose().verbose
+    
+    def __enter__(self):
+        '''Enter context'''
+        Verbose().incr()
+        return self
+
+    def __exit__(self,*args):
+        '''Exit context'''        
+        Verbose().decr()
+
+    @property
+    def i(self):
+        return Verbose()._indent
+    
+    def __call__(self,*args,**kwargs):
+        '''Write a message at current indention level
+        
+        Parameters
+        ----------
+        args : tuple
+            Arguments
+        kwargs : dict
+            Keyword arguments
+        '''                
+        Verbose().message(*args,**kwargs)
+
+#
+# EOF
+#

pywargame/cyberboard/__init__.py

@@ -0,0 +1,18 @@
+from . archive import *
+from . base import *
+from . head import *
+from . image import *
+from . tile import *
+from . piece import *
+from . mark import *
+from . draw import *
+from . cell import *
+from . board import *
+from . gamebox import *
+from . scenario import *
+from . player import *
+from . windows import *
+from . palette import *
+from . tray import *
+from . extractor import *
+