用于解析FBNeo游戏数据的Python3脚本

struct BurnDriver BurnDrvCpsStriderua = {
	"striderua", "strider", NULL, NULL, "1989",
	"Strider (US set 2)\0", NULL, "Capcom", "CPS1",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_CAPCOM_CPS1, GBF_PLATFORM, 0,
	NULL, StrideruaRomInfo, StrideruaRomName, NULL, NULL, NULL, NULL, StriderInputInfo, StrideruaDIPInfo,
	StriderInit, DrvExit, Cps1Frame, CpsRedraw, CpsAreaScan,
	&CpsRecalcPal, 0x1000, 384, 224, 4, 3
};

struct BurnDriver {
	char* szShortName;			// The filename of the zip file (without extension)
	char* szParent;				// The filename of the parent (without extension, NULL if not applicable)
	char* szBoardROM;			// The filename of the board ROMs (without extension, NULL if not applicable)
	char* szSampleName;			// The filename of the samples zip file (without extension, NULL if not applicable)
	char* szDate;

	// szFullNameA, szCommentA, szManufacturerA and szSystemA should always contain valid info
	// szFullNameW, szCommentW, szManufacturerW and szSystemW should be used only if characters or scripts are needed that ASCII can't handle
	char*    szFullNameA; char*    szCommentA; char*    szManufacturerA; char*    szSystemA;
	wchar_t* szFullNameW; wchar_t* szCommentW; wchar_t* szManufacturerW; wchar_t* szSystemW;

	INT32 Flags;			// See burn.h
	INT32 Players;		// Max number of players a game supports (so we can remove single player games from netplay)
	INT32 Hardware;		// Which type of hardware the game runs on
	INT32 Genre;
	INT32 Family;
	INT32 (*GetZipName)(char** pszName, UINT32 i);				// Function to get possible zip names
	INT32 (*GetRomInfo)(struct BurnRomInfo* pri, UINT32 i);		// Function to get the length and crc of each rom
	INT32 (*GetRomName)(char** pszName, UINT32 i, INT32 nAka);	// Function to get the possible names for each rom
	INT32 (*GetHDDInfo)(struct BurnHDDInfo* pri, UINT32 i);			// Function to get hdd info
	INT32 (*GetHDDName)(char** pszName, UINT32 i, INT32 nAka);		// Function to get the possible names for each hdd
	INT32 (*GetSampleInfo)(struct BurnSampleInfo* pri, UINT32 i);		// Function to get the sample flags
	INT32 (*GetSampleName)(char** pszName, UINT32 i, INT32 nAka);	// Function to get the possible names for each sample
	INT32 (*GetInputInfo)(struct BurnInputInfo* pii, UINT32 i);	// Function to get the input info for the game
	INT32 (*GetDIPInfo)(struct BurnDIPInfo* pdi, UINT32 i);		// Function to get the input info for the game
	INT32 (*Init)(); INT32 (*Exit)(); INT32 (*Frame)(); INT32 (*Redraw)(); INT32 (*AreaScan)(INT32 nAction, INT32* pnMin);
	UINT8* pRecalcPal; UINT32 nPaletteEntries;										// Set to 1 if the palette needs to be fully re-calculated
	INT32 nWidth, nHeight; INT32 nXAspect, nYAspect;					// Screen width, height, x/y aspect
};

#define BurnDriverD BurnDriver		// Debug status
#define BurnDriverX BurnDriver		// Exclude from build

#!/usr/bin/python3
# -*- coding: UTF-8 -*-

import os
import time
import re
from shutil import copyfile
from xml.etree import ElementTree as et
from xml.dom import minidom
from datetime import datetime

do_copy = 1
target_folder = r'D:\temp\toaplan'
sub_roms_folder = 'toaplan'
fbneo_src_folder = r'drv\toaplan'
sub_images_folder = 'toaplan_images'

fbneo_rom_folder = r'D:\Backup\ent\Games\fbneo\roms'
fbneo_preview_folder = r'D:\Backup\ent\Games\fbneo\support\previews'
fbneo_title_folder = r'D:\Backup\ent\Games\fbneo\support\titles'


fbneo_genres = {
    'GBF_HORSHOOT': 'Shooter / Horizontal / Sh\'mup',
    'GBF_VERSHOOT': 'Shooter / Vertical / Sh\'mup',
    'GBF_SCRFIGHT': 'Fighting / Beat \'em Up',
    'GBF_VSFIGHT': 'Fighting / Versus',
    'GBF_BIOS': 'BIOS',
    'GBF_BREAKOUT': 'Breakout',
    'GBF_CASINO': 'Casino',
    'GBF_BALLPADDLE': 'Ball & Paddle',
    'GBF_MAZE': 'Maze',
    'GBF_MINIGAMES': 'Mini-Games',
    'GBF_PINBALL': 'Pinball',
    'GBF_PLATFORM': 'Platform',
    'GBF_PUZZLE': 'Puzzle',
    'GBF_QUIZ': 'Quiz',
    'GBF_SPORTSMISC': 'Sports',
    'GBF_SPORTSFOOTBALL': 'Sports / Football',
    'GBF_MISC': 'Misc',
    'GBF_MAHJONG': 'Mahjong',
    'GBF_RACING': 'Racing',
    'GBF_SHOOT': 'Shooter',
    'GBF_ACTION': 'Action (Classic)',
    'GBF_RUNGUN': 'Run \'n Gun (Shooter)',
    'GBF_STRATEGY': 'Strategy',
    'GBF_VECTOR': 'Vector'
}

fbneo_genres_cn = {
    'GBF_HORSHOOT': '横向射击',
    'GBF_VERSHOOT': '竖向射击',
    'GBF_SCRFIGHT': '战斗击打',
    'GBF_VSFIGHT': '对战格斗',
    'GBF_BIOS': 'BIOS',
    'GBF_BREAKOUT': '休闲',
    'GBF_CASINO': '博彩',
    'GBF_BALLPADDLE': '击球',
    'GBF_MAZE': '迷宫',
    'GBF_MINIGAMES': '迷你小游戏',
    'GBF_PINBALL': '弹球',
    'GBF_PLATFORM': '平台',
    'GBF_PUZZLE': '猜谜',
    'GBF_QUIZ': '问答',
    'GBF_SPORTSMISC': '运动',
    'GBF_SPORTSFOOTBALL': '足球运动',
    'GBF_MISC': '其他',
    'GBF_MAHJONG': '麻将',
    'GBF_RACING': '赛道',
    'GBF_SHOOT': '射击',
    'GBF_ACTION': '动作(经典)',
    'GBF_RUNGUN': '运动射击',
    'GBF_STRATEGY': '策略',
    'GBF_VECTOR': 'Vector'
}


def read_file(file_path, encoding='UTF-8'):
    root_path = os.path.dirname(__file__)
    real_path = os.path.join(root_path, file_path)
    f = open(real_path, encoding=encoding)
    print(real_path)
    content = f.read()
    return content


def list_all_files(file_path):
    root_path = os.path.dirname(__file__)
    real_path = os.path.join(root_path, file_path)
    files = []
    for f in os.listdir(real_path):
        f_path = os.path.join(real_path, f)
        if os.path.isfile(f_path):
            files.append(os.path.join(file_path, f))
        else:
            files.extend(list_all_files(os.path.join(file_path, f)))
    return files


def to_datetime(str):
    if not re.match('^\d{4}$', str) is None:
        t = datetime.strptime(str, '%Y')
        return t.strftime('%Y%m%dT%H%M%S')
    else:
        return None


def get_genre(str):
    if str is None:
        return None
    else:
        keys = str.split('|')
        for key in keys:
            key = key.strip()
            if key == 'GBF_VECTOR':
                continue
            if key in fbneo_genres:
                # print(fbneo_genres[key])
                return fbneo_genres[key]
        return None


def dequote(str):
    if (str == 'NULL'):
        return None
    else:
        match = re.match(r'L?"(.*)"', str)
        return match.group(1).strip()


def dequote2(str):
    if (str == 'NULL'):
        return None
    else:
        match = re.match(r'L?"(.*)\\0"', str)
        return match.group(1).strip()


def dequote2unicode(str):
    if (str == 'NULL'):
        return None
    else:
        match = re.match(r'L?"(.*)\\0"', str)
        return match.group(1).strip().replace(r'\0', ' ').encode('utf-8').decode('unicode_escape')


def dict_to_elem(dictionary):
    item = et.Element('game')
    for key in dictionary:
        field = et.Element(key)
        field.text = dictionary[key]
        item.append(field)
    return item


def prettify(elem):
    rough_string = et.tostring(elem, 'utf-8')
    reparsed = minidom.parseString(rough_string)
    return reparsed.toprettyxml(indent="  ")

def check_and_mkdir(path):
    if not os.path.isdir(path):
        try:
            os.mkdir(path)
        except OSError:
            print("Creation of the directory %s failed" % path)
        else:
            print("Successfully created the directory %s " % path)


print('[*] Fetch games')

files = list_all_files(fbneo_src_folder)

games = []
for f in files:
    content = read_file(f, 'iso-8859-1')
    result = re.compile(r'struct\s+BurnDriverD?\s+Burn.*\s+=\s+\{[^}]+\};').findall(content)
    if (len(result) > 0):
        for idx, line in enumerate(result):
            print(idx, line)
            # remote the comments
            line = re.sub(r'(\/\/.*\n|\n+)', r'\n', line)  # remove the // comments
            line = re.sub(r'\/\*[\w\s=,|]+\*\/', '', line)  # remove the  /* */ comments
            line = re.sub(r'\s+,', ',', line)  # remove the space before comma
            line = re.sub(r'\s+', ' ', line)  # remove all new lines

            # print(idx, line)
            # BurnDriver, BurnDriverD
            match = re.match(r'struct\s+BurnDriverD?\s+Burn.*\s+=\s+\{'
                             r'\s+(["\w]+|NULL),\s*(["\w]+|NULL),\s*(["\w]+|NULL),\s*(["\w]+|NULL),\s*(["\w\?\+\s]+|NULL),'
                             r'\s*("(?:\\.|[^"\\])*"|NULL),\s*("(?:\\.|[^"\\])*"|NULL),\s*("(?:\\.|[^"\\])*"|NULL),\s*("(?:\\.|[^"\\])*"|NULL),'
                             r'\s*(L"(?:\\.|[^"\\])*"|NULL),\s*(L"(?:\\.|[^"\\])*"|NULL),\s*(L"(?:\\.|[^"\\])*"|NULL),\s*(L"(?:\\.|[^"\\])*"|NULL),'
                             r'\s*([0-9A-Z_\s|/\*]+),\s*(\d+),\s*([\w\s|/]+),\s*([0-9A-Z_\s|]+),\s*([0-9A-Z_\s|]+),'
                             r'\s*(\w+|NULL),\s*(\w+|NULL),\s*(\w+|NULL),\s*(\w+|NULL),\s*(\w+|NULL),\s*(\w+|NULL),\s*(\w+|NULL),\s*(\w+|NULL),\s*(\w+|NULL),'
                             r'\s*(\w+),\s*(\w+),\s*(\w+),\s*(\w+),\s*(\w+),'
                             r'\s*(&\w+|NULL),\s*([\w\s\*]+),'
                             r'\s*(\d+|\w+|\d+\*2),\s*(\d+|\w+),\s*(\d+),\s*(\d+)'
                             r'([^}]+)\};', line)
            game = {}
            game['shortName'] = dequote(match.group(1))
            game['parent'] = dequote(match.group(2))
            game['boardRom'] = dequote(match.group(3))
            game['sampleName'] = dequote(match.group(4))
            game['date'] = dequote(match.group(5))
            game['datetime'] = to_datetime(game['date'])

            game['fullNameA'] = dequote2(match.group(6))
            game['fullCommentA'] = dequote(match.group(7))
            game['manufacturerA'] = dequote(match.group(8))
            game['systemA'] = dequote(match.group(9))

            game['fullNameW'] = dequote2unicode(match.group(10))
            game['fullCommentW'] = match.group(11)
            game['manufacturerW'] = match.group(12)
            game['systemW'] = match.group(13)

            game['flags'] = match.group(14)
            game['players'] = match.group(15)
            game['hardware'] = match.group(16)
            game['genre'] = match.group(17)
            game['genre_text'] = get_genre(game['genre'])
            game['family'] = match.group(18)

            game['GetZipName'] = match.group(19)
            game['GetRomInfo'] = match.group(20)
            game['GetRomName'] = match.group(21)
            game['GetHDDInfo'] = match.group(22)
            game['GetHDDName'] = match.group(23)
            game['GetSampleInfo'] = match.group(24)
            game['GetSampleName'] = match.group(25)
            game['GetInputInfo'] = match.group(26)
            game['GetDIPInfo'] = match.group(27)

            game['init'] = match.group(28)
            game['exit'] = match.group(29)
            game['frame'] = match.group(30)
            game['redraw'] = match.group(31)
            game['areaScan'] = match.group(32)
            # UINT8* pRecalcPal; UINT32 nPaletteEntries
            game['recalcPal'] = match.group(33)
            game['paletteEntries'] = match.group(34)
            # INT32 nWidth, nHeight; INT32 nXAspect, nYAspect;
            game['width'] = match.group(35)
            game['height'] = match.group(36)
            game['xaspect'] = match.group(37)
            game['yaspect'] = match.group(38)

            # print(game['fullNameW'],game['fullCommentW'],game['manufacturerW'],game['systemW'])
            # print(game['fullNameW'], game['fullNameW'].replace(r'\0', ' ').encode('utf-8').decode('unicode_escape'))
            print(game)
            games.append(game)

target_roms_folder = os.path.join(target_folder, sub_roms_folder)
check_and_mkdir(target_roms_folder)
target_images_folder = os.path.join(target_folder, sub_images_folder)
check_and_mkdir(target_images_folder)

# compose the xml file
root = et.Element('gameList')  # create the element first...
tree = et.ElementTree(root)  # and pass it to the created tree

for game in games:
    rom_file = os.path.join(fbneo_rom_folder, game['shortName'] + '.zip')
    preview_file = os.path.join(fbneo_preview_folder, game['shortName'] + '.png')
    title_file = os.path.join(fbneo_title_folder, game['shortName'] + '.png')
    if not os.path.isfile(rom_file):
        print('nonexists: {}'.format(rom_file))
        continue
    elif do_copy == 1:
        # Do the copy
        copyfile(rom_file, os.path.join(target_roms_folder, game['shortName'] + '.zip'))

    if not os.path.isfile(preview_file):
        image_str = None
        print('nonexists: {}'.format(preview_file))
    else:
        image_str = './' + sub_images_folder +'/' + game['shortName'] + '.png'
        if do_copy == 1:
            copyfile(preview_file, os.path.join(target_images_folder, game['shortName'] + '.png'))

    if not os.path.isfile(title_file):
        marquee_str = None
        print('nonexists: {}'.format(title_file))
    else:
        marquee_str = './' + sub_images_folder + '/' + game['shortName'] + '_marquee.png'
        if do_copy == 1:
            copyfile(title_file, os.path.join(target_images_folder, game['shortName'] + '_marquee.png'))

    node = {
        'path': './' + sub_roms_folder + '/' + game['shortName'] + '.zip',
        'name': game['fullNameA'] if game['fullNameW'] is None else game['fullNameW'],
        'desc': '' if game['fullCommentA'] is None else game['fullCommentA'],
        'image': image_str,
        'marquee': marquee_str,
        'releasedate': game['datetime'],
        'developer': '' if game['manufacturerA'] is None else game['manufacturerA'],
        'publisher': '' if game['systemA'] is None else game['systemA'],
        'genre': game['genre_text'],
        'players': game['players']
    }
    root.append(dict_to_elem(node))

xml_content = prettify(root)

filename = os.path.join(target_folder, 'gamelist.xml')
with open(filename, 'w', newline = '\n', encoding='utf-8') as file:
    file.write(xml_content)

print('Done')

"(?:\\.|[^"\\])*"

"       # Match a quote.
(?:     # Either match...
 \\.    # an escaped character
|       # or
 [^"\\] # any character except quote or backslash.
)*      # Repeat any number of times.
"       # Match another quote.

<game>

    name - string, the displayed name for the game.
    desc - string, a description of the game. Longer descriptions will automatically scroll, so don't worry about size.
    image - image_path, the path to an image to display for the game (like box art or a screenshot).
    thumbnail - image_path, the path to a smaller image, displayed in image lists like the grid view. Should be small to ensure quick loading. Currently not used.
    rating - float, the rating for the game, expressed as a floating point number between 0 and 1. Arbitrary values are fine (ES can display half-stars, quarter-stars, etc).
    releasedate - datetime, the date the game was released. Displayed as date only, time is ignored.
    developer - string, the developer for the game.
    publisher - string, the publisher for the game.
    genre - string, the (primary) genre for the game.
    players - integer, the number of players the game supports.
    playcount - statistic, integer, the number of times this game has been played
    lastplayed - statistic, datetime, the last date and time this game was played.

<folder>

    name - string, the displayed name for the folder.
    desc - string, the description for the folder.
    image - image_path, the path to an image to display for the folder.
    thumbnail - image_path, the path to a smaller image to display for the folder. Currently not used.