mirror of
git://xwords.git.sourceforge.net/gitroot/xwords/xwords
synced 2025-01-03 23:04:08 +01:00
132 lines
4.7 KiB
Python
Executable file
132 lines
4.7 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
import argparse, os, re, struct, sys
|
|
|
|
def errorOut(msg):
|
|
print('ERROR: {}'.format(msg))
|
|
sys.exit(1)
|
|
|
|
def mkParser():
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument('-enc', dest = 'ENCODING', type = str, help = 'use this encoding' )
|
|
parser.add_argument('-tn', dest = 'DO_TABLE', action = 'store_true', help = 'output table file' )
|
|
|
|
# parser.add_argument('-tn', dest = 'UNICODE', default = False,
|
|
# action = 'store_true', help = 'assume unicode')
|
|
# parser.add_argument('-t', dest = 'UNICODE', type = str, default = True,
|
|
# action = 'store_false', help = 'DO NOT assume unicode')
|
|
parser.add_argument('-v', dest = 'DO_VALS', action = 'store_true', help = 'output values file' )
|
|
parser.add_argument('-s', dest = 'DO_SIZE', action = 'store_true', help = 'output size file')
|
|
parser.add_argument('-out', dest = 'OUTFILE', type = str, help = 'outfile path')
|
|
|
|
parser.add_argument('--table-file', dest = 'TABLE_FILE', type = str, help = 'write table file here')
|
|
parser.add_argument('--size-file', dest = 'SIZE_FILE', type = str, help = 'write size file here')
|
|
parser.add_argument('--vals-file', dest = 'VALS_FILE', type = str, help = 'write vals file here')
|
|
|
|
return parser
|
|
|
|
sPreComment = re.compile('^(.*)#.*$')
|
|
sVarAssign = re.compile('^(\w+):(.*)$')
|
|
sBeginTiles = re.compile('^<BEGIN_TILES>$')
|
|
sEndTiles = re.compile('^<END_TILES>$')
|
|
sSingleCharMatch = re.compile("'(.(\|.)*)'")
|
|
sSpecialsMatch = re.compile('{"(.+)"(,.+)?}')
|
|
|
|
def parseTileInfo(infoFile, encoding):
|
|
result = {'_TILES' : []}
|
|
with open(infoFile, 'rt') as file:
|
|
data = file.read()
|
|
# if encoding:
|
|
# data = data.decode(encoding)
|
|
data = data.split('\n')
|
|
|
|
inTiles = False
|
|
tiles = []
|
|
for line in data:
|
|
# print('line at start: {}'.format(line))
|
|
match = sPreComment.match(line)
|
|
if match:
|
|
line = match.group(1)
|
|
# print('line sans comment: {}'.format(line))
|
|
if 0 == len(line):continue
|
|
|
|
if inTiles:
|
|
if sEndTiles.match(line):
|
|
break
|
|
else:
|
|
(count, val, face) = line.split(None, 2)
|
|
result['_TILES'].append((count, val, face))
|
|
elif sBeginTiles.match(line):
|
|
inTiles = True
|
|
else:
|
|
match = sVarAssign.match(line)
|
|
if match:
|
|
var = match.group(1)
|
|
if not var in result: result[var] = ''
|
|
result[var] += match.group(2)
|
|
|
|
return result
|
|
|
|
def printLetters( letters, outfile ):
|
|
letters = letters.split('|')
|
|
letters = ' '.join(letters)
|
|
outfile.write(letters.encode('utf8'))
|
|
|
|
def writeMapFile(xlocToken, outfile):
|
|
print('writeMapFile()')
|
|
tiles = xlocToken['_TILES']
|
|
specialCount = 0
|
|
for tile in tiles:
|
|
face = tile[2]
|
|
match = sSingleCharMatch.match(face)
|
|
if match:
|
|
printLetters( match.group(1), outfile )
|
|
continue
|
|
match = sSpecialsMatch.match(face)
|
|
if match:
|
|
print('specials char: {}'.format(match.group(1)))
|
|
outfile.write(struct.pack('B', specialCount ))
|
|
specialCount += 1
|
|
continue
|
|
|
|
print('bad/unmatched face: {}'.format(face))
|
|
assert False
|
|
|
|
def writeValuesFile(xlocToken, outfile):
|
|
header = xlocToken.get('XLOC_HEADER') or errorOut('no XLOC_HEADER found')
|
|
|
|
print('writing header: {}'.format(header))
|
|
outfile.write(struct.pack('!H', int(header, 16)))
|
|
|
|
for tile in xlocToken['_TILES']:
|
|
val = int(tile[0])
|
|
count = int(tile[1])
|
|
outfile.write(struct.pack('BB', val, count))
|
|
|
|
def main():
|
|
print('{}.main {} called'.format(sys.argv[0], sys.argv[1:]))
|
|
args = mkParser().parse_args()
|
|
|
|
infoFile = 'info.txt'
|
|
if not os.path.exists(infoFile):
|
|
errorOut('{} not found'.format(infoFile))
|
|
xlocToken = parseTileInfo(infoFile, args.ENCODING)
|
|
|
|
if args.DO_TABLE or args.TABLE_FILE:
|
|
path = args.TABLE_FILE or args.OUTFILE
|
|
with open(path, 'wb') as outfile:
|
|
writeMapFile(xlocToken, outfile);
|
|
|
|
if args.DO_SIZE or args.SIZE_FILE:
|
|
path = args.SIZE_FILE or args.OUTFILE
|
|
with open(path, 'wb') as outfile:
|
|
count = len(xlocToken['_TILES'])
|
|
outfile.write(struct.pack('B', count))
|
|
|
|
if args.DO_VALS or args.VALS_FILE:
|
|
path = args.VALS_FILE or args.OUTFILE
|
|
with open(path, 'wb') as outfile:
|
|
writeValuesFile( xlocToken, outfile )
|
|
|
|
##############################################################################
|
|
if __name__ == '__main__':
|
|
main()
|