145 lines
4.1 KiB
Python
Executable File
145 lines
4.1 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import os
|
|
|
|
from unidecode import unidecode
|
|
|
|
import config
|
|
import parser
|
|
import flow
|
|
|
|
japanese_ranges = [
|
|
(0x4E00, 0x9FFF), # Kanji
|
|
(0x3040, 0x309F), # Hiragana
|
|
(0x30A0, 0x30FF), # Katakana
|
|
(0xFF00, 0xFFEF), # Full-width Roman characters and symbols
|
|
(0x3000, 0x303F), # CJK symbols and punctuation (including 「」)
|
|
]
|
|
|
|
|
|
def process_sections():
|
|
output_filepath = os.path.join(config.get('output_path'), 'out.txt')
|
|
outfile = open(output_filepath, 'w', encoding='shift_jisx0213')
|
|
origfile = open(config.get('original_path'), 'r', encoding='shift_jisx0213')
|
|
|
|
sections = dict()
|
|
|
|
for line in origfile:
|
|
if line.startswith('*'):
|
|
section_name = line[1:].split(' ', 1)[0].replace('\n','')
|
|
|
|
outfile.write(line)
|
|
|
|
if section_name in flow.onik:
|
|
print("entering", section_name)
|
|
write_translated(
|
|
outfile,
|
|
origfile,
|
|
flow.onik[section_name],
|
|
)
|
|
else:
|
|
outfile.write(line)
|
|
|
|
outfile.close()
|
|
origfile.close()
|
|
|
|
|
|
def get_symbols(line: str) -> list[str]:
|
|
res = []
|
|
|
|
inbetween = 0
|
|
i = 0
|
|
while i < len(line):
|
|
if line[i] in ['@', '/', '¥']:
|
|
symbol = line[i]
|
|
elif line[i:i+3] == '!sd':
|
|
symbol = line[i:i+3]
|
|
i += 3
|
|
elif line[i:i+2] in ['!d', '!w', '!s']:
|
|
x = i
|
|
i += 2
|
|
while i < len(line):
|
|
if line[i].isdigit():
|
|
i += 1
|
|
continue
|
|
|
|
symbol = line[x:i]
|
|
break
|
|
elif line[i] == '!':
|
|
raise Exception('Unhandled symbol', line)
|
|
else: # It's not a symbol, it's a regular character
|
|
inbetween += 1
|
|
i += 1
|
|
continue
|
|
|
|
# Only reaches this if it's a
|
|
if inbetween > 0:
|
|
res.append(symbol)
|
|
else:
|
|
res[-1] += symbol
|
|
inbetween = 0
|
|
|
|
i += 1
|
|
|
|
return res
|
|
|
|
|
|
# Given a set of translation files, the original file and the output file
|
|
# replace the japanese lines with the translated ones in a given section.
|
|
def write_translated(outfile, origfile, translation_file_paths):
|
|
for transfilepath in translation_file_paths:
|
|
print(f'- reading "{transfilepath}"')
|
|
structure = parser.parse_to_structure(transfilepath)
|
|
|
|
for i, line in enumerate(origfile):
|
|
# Check if the current line is a dialogue line or not
|
|
found = False
|
|
for start, end in japanese_ranges:
|
|
if start <= ord(line[0]) <= end:
|
|
found = True
|
|
|
|
if found:
|
|
# The amount of lines may not coincide because the original
|
|
# might have one line for what we have multiple lines. Count
|
|
# the number of appearances of the end-of-command symbols
|
|
# (@ and ¥) to determine how many of the translated lines is
|
|
# equivalent to the given original line.
|
|
amount = line.count("@") + line.count("¥") + line.count('/')
|
|
|
|
symbols = get_symbols(line)
|
|
print(symbols, line, end='')
|
|
continue
|
|
|
|
outfile.write('`')
|
|
|
|
_printed_line = ""
|
|
while True:
|
|
if amount <= 0:
|
|
break
|
|
|
|
if structure[0].type == 'Line_ContinueAfterTyping':
|
|
amount += 1
|
|
|
|
_printed_line += structure[0].text_jp
|
|
outfile.write(
|
|
unidecode(structure.pop(0).text_en).replace("\\", "¥")
|
|
)
|
|
|
|
amount -= 1
|
|
|
|
outfile.write('\n')
|
|
|
|
print("\n-", transfilepath)
|
|
print(">", _printed_line)
|
|
print("<", line, end='')
|
|
|
|
|
|
# Used up all of the structures, this chapter has ended.
|
|
# Got to the next one
|
|
if len(structure) <= 0:
|
|
break
|
|
|
|
else:
|
|
outfile.write(line)
|
|
|