juegos

mkpieces.py (3543B)

---

 #!/usr/bin/env python3
 """Genera gfx/pieces.c: sprites de las piezas a partir de los glifos de ajedrez de
 DejaVu Sans. Cada pixel usa 2 bits: 0 transparente, 1 cuerpo, 2 contorno/detalle.
 Uso: python3 tools/mkpieces.py > gfx/pieces.c   (con --png ARCHIVO hace una muestra)"""
 import sys
 from PIL import Image, ImageDraw, ImageFont, ImageFilter, ImageChops
 
 FONT = '/usr/share/fonts/TTF/DejaVuSans.ttf'
 SIZES = [48, 32]
 ORDER = 'PNBRQK'
 FILLED = {'K': '♚', 'Q': '♛', 'R': '♜', 'B': '♝', 'N': '♞', 'P': '♟'}
 HOLLOW = {'K': '♔', 'Q': '♕', 'R': '♖', 'B': '♗', 'N': '♘', 'P': '♙'}
 
 def glyph(ch, size, box):
     f = ImageFont.truetype(FONT, box)
     im = Image.new('L', (size * 2, size * 2), 0)
     ImageDraw.Draw(im).text((size, size), ch, font=f, fill=255, anchor='mm')
     return im
 
 def sprite(p, size):
     box = int(size * 1.02)
     full = glyph(FILLED[p], size, box)
     hollow = glyph(HOLLOW[p], size, box)
     bb = full.getbbox()
     cx, cy = (bb[0] + bb[2]) // 2, (bb[1] + bb[3]) // 2
     off = (cx - size // 2, cy - size // 2 - (size // 24))
     crop = lambda im: im.crop((off[0], off[1], off[0] + size, off[1] + size))
     full, hollow = crop(full), crop(hollow)
     body = full.point(lambda v: 255 if v > 110 else 0)
     # cuerpo = silueta rellena: el glifo hueco relleno por dentro coincide con el lleno
     outer = body.filter(ImageFilter.MaxFilter(3))
     outline = ImageChops.subtract(outer, body)
     # detalle interior: las lineas del glifo hueco que caen dentro del cuerpo
     detail = hollow.point(lambda v: 255 if v > 140 else 0)
     inner = body.filter(ImageFilter.MinFilter(3))
     detail = ImageChops.multiply(detail, inner)
     px = []
     for y in range(size):
         for x in range(size):
             if outline.getpixel((x, y)) or detail.getpixel((x, y)): px.append(2)
             elif body.getpixel((x, y)): px.append(1)
             else: px.append(0)
     return px
 
 def main():
     if len(sys.argv) > 2 and sys.argv[1] == '--png':
         W = sum(SIZES) + 8
         im = Image.new('RGB', (len(ORDER) * 2 * (SIZES[0] + 4), W * 1), (120, 140, 90))
         x = 0
         for col, (b, o) in enumerate([((240, 240, 230), (20, 20, 20)), ((30, 30, 34), (200, 200, 200))]):
             for p in ORDER:
                 y = 0
                 for s in SIZES:
                     px = sprite(p, s)
                     for i, v in enumerate(px):
                         if v: im.putpixel((x + i % s, y + i // s), b if v == 1 else o)
                     y += s + 4
                 x += SIZES[0] + 4
         im.resize((im.width * 3, im.height * 3), Image.NEAREST).save(sys.argv[2])
         return
     print('/* pieces.c - sprites de las piezas, generado por tools/mkpieces.py (glifos de DejaVu Sans). No editar. */')
     print('#include "chess_gfx.h"\n')
     for s in SIZES:
         for p in ORDER:
             px = sprite(p, s)
             data = []
             for i in range(0, len(px), 4):
                 b = 0
                 for k in range(4):
                     b |= px[i + k] << (2 * k)
                 data.append(b)
             print('static const uint8_t P%d_%s[%d] = {' % (s, p, len(data)))
             for i in range(0, len(data), 24):
                 print('    ' + ', '.join('0x%02x' % v for v in data[i:i + 24]) + ',')
             print('};')
     print('\nconst PieceSet PIECES[%d] = {' % len(SIZES))
     for s in SIZES:
         print('    { %d, { 0, %s } },' % (s, ', '.join('P%d_%s' % (s, p) for p in ORDER)))
     print('};')
     print('const int NPIECESETS = %d;' % len(SIZES))
 
 main()