def asset_object_from(data: str) -> SObject:
assert isinstance(data, str)
logger.debug(msg.PROC_START.format(proc=PROC))
tmp = assertion.is_dict(yaml.safe_load(data))
obj = None
if str(AssetType.PERSON) in tmp:
obj = Converter.to_person(tmp[str(AssetType.PERSON)])
elif str(AssetType.STAGE) in tmp:
obj = Converter.to_stage(tmp[str(AssetType.STAGE)])
elif str(AssetType.ITEM) in tmp:
obj = Converter.to_item(tmp[str(AssetType.ITEM)])
elif str(AssetType.MOB) in tmp:
obj = Converter.to_nametag(tmp)
elif str(AssetType.TIME) in tmp:
obj = Converter.to_nametag(tmp)
elif str(AssetType.WORD) in tmp:
obj = Converter.to_nametag(tmp)
elif str(AssetType.RUBI) in tmp:
obj = Converter.to_rubi(tmp[str(AssetType.RUBI)])
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA_WITH_DATA.format(
data=f"asset type: {PROC}"), tmp.keys())
return None
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return obj
def get_assets_db() -> AssetsDB:
_PROC = f"{PROC}: get assets db"
logger.debug(msg.PROC_START.format(proc=_PROC))
db = AssetsDB()
paths = get_filepaths_in(PM.get_asset_dir_path(), EXT_YAML, True)
for path in paths:
if not is_exists_path(path):
logger.warning(
msg.ERR_FAIL_MISSING_DATA.format(
data=f"asset data of {path}: {PROC}"))
continue
data = read_file(path)
# NOTE: file validate?
obj = asset_object_from(data)
if obj:
assert isinstance(obj, SObject)
db.add(obj.tag, obj)
logger.debug(
msg.PROC_MESSAGE.format(proc=f"Add '{obj.tag}' to asset db"))
logger.debug(msg.PROC_SUCCESS.format(proc=_PROC))
return db
def _conv_person(level: str, index: str, subject: str, type: PersonInOut,
outline: str) -> str:
assert isinstance(level, str)
assert isinstance(index, str)
assert isinstance(subject, str)
assert isinstance(type, PersonInOut)
assert isinstance(outline, str)
be = into = outto = wear = ''
if PersonInOut.BE is type:
be = 'BE'
elif PersonInOut.IN is type:
into = 'IN'
elif PersonInOut.OUT is type:
outto = 'OUT'
elif PersonInOut.WEAR is type:
wear = 'WEAR'
else:
logger.warning(
msg.ERR_FAIL_UNKNOWN_DATA_WITH_DATA.format(
data=f"format person info: {PROC}"), type)
_level = just_string_of(level, 4)
_index = just_string_of(index, 4)
_subject = just_string_of(subject, 16)
_be = just_string_of(be, 4)
_in = just_string_of(into, 4)
_out = just_string_of(outto, 4)
_wear = just_string_of(wear, 4)
_outline = just_string_of(outline, 16)
return f"| {_level} | {_index} | {_subject} | {_be} | {_in} | {_out} | {_wear} | {_outline} |"
def run(self) -> int:
logger.debug(msg.PROC_START.format(proc=PROC))
args = get_commandline_arguments()
if not args:
logger.error(
msg.ERR_FAIL_MISSING_DATA.format(
data=f"command line args: {PROC}"))
return os.EX_NOINPUT
if BuildChecker.has_build_cmd_of(args, BuildType.BUILD):
if not build_project(args):
logger.debug(
msg.ERR_FAIL_SUBPROCESS.format(
proc=f"build project: {PROC}"))
return os.EX_SOFTWARE
elif BuildChecker.has_build_cmd_of(args, BuildType.INIT):
if not init_project():
logger.debug(
msg.ERR_FAIL_SUBPROCESS.format(
proc=f"init project: {PROC}"))
return os.EX_SOFTWARE
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA_WITH_DATA.format(
data=f"build command: {PROC}"), args.cmd)
return os.EX_NOINPUT
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return os.EX_OK
def scene_code_object_from(raw: RawSrc) -> SceneCode:
assert isinstance(raw, RawSrc)
logger.debug(msg.PROC_START.format(proc=PROC))
code = SceneCode(raw.tag)
current_act = None
def _store_act(scode: SceneCode, act):
assert isinstance(scode, SceneCode)
if act:
assert isinstance(act, (Action, Instruction))
scode.add(act.cloned())
return None
for line in raw.data:
assert isinstance(line, str)
if line.startswith('<'):
ret = Converter.to_call_scene(line)
if ret:
current_act = _store_act(code, current_act)
code.add(ret)
elif line.startswith('::'):
# member
member, val = _get_member_tokens(line)
if not member:
logger.warning(
msg.ERR_FAIL_MISSING_DATA.format(
data=f"member:'{member}' and val: '{val}' : {PROC}"))
continue
if hasattr(code, member):
setattr(code, member, val)
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA_WITH_DATA.format(
data=f"scene member: {PROC}"), member)
elif line.startswith('!'):
# instruction
ret = Converter.to_instruction(line)
if ret:
current_act = _store_act(code, current_act)
code.add(ret)
elif line.startswith('['):
# action
current_act = _store_act(code, current_act)
current_act = Converter.to_action(line)
elif line:
# text
if current_act:
current_act.add(line)
else:
continue
current_act = _store_act(code, current_act)
updated_code = Restructor.restruct_dialogue_actions(code)
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return updated_code
def create_default_dirs(cls) -> bool:
for dirname in DEF_DIRS:
_dirname = os.path.join(DIR_PROJECT, dirname)
if not cls._safe_create_dir(_dirname):
logger.warning(
msg.ERR_FAIL_CANNOT_CREATE_DATA.format(data=f"{_dirname}"))
return False
return True
def _set_data_attr(obj: SObject, data: dict) -> bool:
assert isinstance(obj, SObject)
assert isinstance(data, dict)
for key, val in data.items():
if key in [ELM_TAG, ELM_NAME]:
continue
if not _safe_set_attr(obj, key, val):
logger.warning(
msg.ERR_FAIL_CANNOT_WRITE_DATA_WITH_DATA.format(
data=f"set '{key}'|'{val}': {PROC}"), obj)
return True
def output_data(path: str, outputs: OutputsData) -> bool:
assert isinstance(path, str)
assert isinstance(outputs, OutputsData)
if not write_file(path, outputs.get_serialized_data()):
logger.warning(
msg.ERR_FAIL_CANNOT_WRITE_DATA.format(
data=f"outputs data to {path}: {PROC}"))
return False
logger.debug(msg.PROC_MESSAGE.format(proc=f"write {path}"))
return True
def _act_type_of(tag: str) -> ActType:
assert isinstance(tag, str)
for act in ActType:
if tag in act.to_checker():
return act
if tag:
logger.warning(
msg.ERR_FAIL_UNKNOWN_DATA_WITH_DATA.format(
data=f"act type string: {PROC}"), tag)
return ActType.NONE
else:
return ActType.SAME
def to_nametag(data: dict) -> NameTag:
assert isinstance(data, dict)
if str(AssetType.MOB) in data:
return NameTag(NameTagType.MOB, data[str(AssetType.MOB)])
elif str(AssetType.TIME) in data:
return NameTag(NameTagType.TIME, data[str(AssetType.TIME)])
elif str(AssetType.WORD) in data:
return NameTag(NameTagType.WORD, data[str(AssetType.WORD)])
else:
logger.warning(
msg.ERR_FAIL_UNKNOWN_DATA.format(
data=f"tag type {data.keys()}: {PROC}"))
return None
def call_scene(level: int, tag: str, scenes: ScenesDB) -> list:
assert isinstance(level, int)
assert isinstance(tag, str)
assert isinstance(scenes, ScenesDB)
if not scenes.has(tag):
logger.warning(
msg.ERR_FAIL_MISSING_DATA_WITH_DATA.format(
data=f"call tag: {PROC}"), tag)
return []
tmp = []
scode = assertion.is_instance(scenes.get(tag), SceneCode)
tmp.append(Converter.conv_scene_info_from(level, scode))
for obj in scode.data:
if isinstance(obj, Action):
tmp.append(obj)
elif isinstance(obj, Instruction):
if InstType.CALL is obj.type:
call_tag = obj.args[0]
# TODO: 親タグも取得して相互呼び出しを禁止する
if tag == call_tag:
logger.error(
msg.ERR_FAIL_MUSTBE_WITH_DATA.format(
data=f"not self calling: {PROC}"), tag)
raise ValueError('invalid self calling', tag)
ret = call_scene(level + 1, obj.args[0], scenes)
if ret:
tmp.extend(ret)
else:
tmp.append(obj)
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA_WITH_DATA.format(
data=f"scene code object: {PROC}"), obj)
continue
tmp.append(_get_scene_end(scode))
return tmp
def callingtags_from(assets: AssetsDB) -> dict:
assert isinstance(assets, AssetsDB)
_PROC = f"{PROC}: calling tags"
logger.debug(msg.PROC_START.format(proc=_PROC))
tmp = {}
for key, val in assets.data.items():
assert isinstance(key, str)
assert isinstance(val, SObject)
if isinstance(val, Person):
if not Converter.person_callings_of(tmp, val):
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"person '{val.tag} calling: {_PROC}'"))
else:
continue
logger.debug(msg.PROC_SUCCESS.format(proc=_PROC))
return tmp
def _to_act(record: StructRecord) -> str:
assert isinstance(record, StructRecord)
act = assertion.is_instance(record.act, ActType)
subject = record.subject if record.subject else '――'
category = act.to_category()
outline = record.outline if record.outline else '――'
indent = get_indent(2)
if act in DIALOGUE_ACTS:
_outline = f"「{outline}」"
if ActType.VOICE is act:
_outline = f"（{category}）『{outline}』"
return f"{subject}{_outline}"
elif act in DOING_ACTS:
return f"{indent}〔{category}〕[{subject}]{outline}"
elif act in DRAW_ACTS:
return f"{indent}＠（{category}）[{subject}]{outline}"
elif act in FLAG_ACTS:
return f"{indent}！（{category}）[{subject}]{outline}"
elif act in STATE_ACTS:
return f"{indent}％（{category}）[{subject}]＝{outline}"
elif act in THINKING_ACTS:
return f"{indent}（{category}）[{subject}]{outline}"
elif act in SELECT_ACTS:
if ActType.CHOICE is act:
return f"{indent}！（{category}）[{subject}]＝{outline}"
else:
assert ActType.SELECTION is act
selects = outline.replace(' ', '').split(',')
_selects = '/'.join(selects)
return f'{indent}？（{category}）[{subject}]＝{_selects}'
elif act in TIME_ACTS:
return f"[XII] {outline}"
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA_WITH_DATA.format(
data=f"act type in format: {PROC}"), act)
return None
def create_base_project_files(cls) -> bool:
for path in BASE_FILES:
if is_exists_path(path):
logger.debug(
msg.PROC_MESSAGE.format(proc=f"Already exists {path}"))
continue
data_path = os.path.join(DIR_DATA, basename_of(path, False))
data = read_file(data_path)
if path == FILE_PROJECT:
data = cls._replace_project_file_data(data)
if write_file(path, data):
logger.debug(msg.PROC_MESSAGE.format(proc=f"Create {path}"))
else:
logger.warning(
msg.ERR_FAIL_CANNOT_WRITE_DATA.format(data=f"{path}"))
return False
return True
def get_srcs_db() -> SrcsDB:
_PROC = f"{PROC}: get sources db"
logger.debug(msg.PROC_START.format(proc=_PROC))
db = SrcsDB()
key_cache = []
paths = get_filepaths_in(PM.get_src_dir_path(), EXT_MARKDOWN, True)
for path in paths:
if not is_exists_path(path):
logger.warning(
msg.ERR_FAIL_MISSING_DATA.format(
data=f"source data of {path}: {PROC}"))
continue
data = read_file(path)
raws = assertion.is_list(raw_src_objects_from(data))
for raw in raws:
if raw:
assert isinstance(raw, RawSrc)
if raw.tag in key_cache:
logger.warning(
msg.ERR_FAIL_DUPLICATED_DATA_WITH_DATA.format(
data=f"tag name: {_PROC}"), raw.tag)
continue
db.add(raw.tag, raw)
key_cache.append(raw.tag)
logger.debug(
msg.PROC_MESSAGE.format(
proc=f"Add '{raw.tag}' to srcs db"))
logger.debug(msg.PROC_SUCCESS.format(proc=_PROC))
return db
def get_commandline_arguments() -> Namespace:
logger.debug(msg.PROC_START.format(proc=PROC))
parser = assertion.is_instance(_init_commandline_parser(),
ArgumentParser)
if not parser:
logger.error(msg.ERR_FAIL_CANNOT_CREATE_DATA.format(data=f"parser: {PROC}"))
return None
if not _set_parser_options(parser):
logger.warning(msg.ERR_FAIL_CANNOT_CREATE_DATA.format(data=f"arg parser options: {PROC}"))
return None
args = parser.parse_args()
if not args:
logger.error(msg.ERR_FAIL_MISSING_DATA.format(data=f"args: {PROC}"))
return None
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return args
def create_common_files(cls) -> bool:
dir_asset = os.path.join(DIR_PROJECT, DEFAULT_ASSET_DIR)
dir_common = os.path.join(dir_asset, DEFAULT_COMMON)
for fname in COMMON_FILES:
_fname = add_extention(fname, EXT_YAML)
data_path = os.path.join(DIR_COMMON, _fname)
data = read_file(data_path)
path = os.path.join(dir_common, _fname)
if is_exists_path(path):
logger.debug(
msg.PROC_MESSAGE.format(proc=f"Already exists {path}"))
continue
if write_file(path, data):
logger.debug(msg.PROC_MESSAGE.format(proc=f"Create {path}"))
else:
logger.warning(
msg.ERR_FAIL_CANNOT_WRITE_DATA.format(data=f"{path}"))
return False
return True
def create_default_files(cls) -> bool:
dir_asset = os.path.join(DIR_PROJECT, DEFAULT_ASSET_DIR)
dir_src = os.path.join(DIR_PROJECT, DEFAULT_SRC_DIR)
dir_temp = os.path.join(DIR_PROJECT, DEFAULT_TEMP_DIR)
for fname in SAMPLE_DATA:
_fname = add_extention(fname, EXT_YAML)
data_path = os.path.join(DIR_EXAMPLE, _fname)
data = read_file(data_path)
path = os.path.join(dir_asset, _fname)
if is_exists_path(path):
logger.debug(
msg.PROC_MESSAGE.format(proc=f"Already exists {path}"))
continue
if write_file(path, data):
logger.debug(msg.PROC_MESSAGE.format(proc=f"Create {path}"))
else:
logger.warning(
msg.ERR_FAIL_CANNOT_WRITE_DATA.format(data=f"{path}"))
return False
for fname in SAMPLE_SRC:
_fname = add_extention(fname, EXT_MARKDOWN)
data_path = os.path.join(DIR_EXAMPLE, _fname)
data = read_file(data_path)
path = os.path.join(dir_src, _fname)
if is_exists_path(path):
logger.debug(
msg.PROC_MESSAGE.format(proc=f"Already exists {path}"))
continue
if write_file(path, data):
logger.debug(msg.PROC_MESSAGE.format(proc=f"Create {path}"))
else:
logger.warning(
msg.ERR_FAIL_CANNOT_WRITE_DATA.format(data=f"{path}"))
return False
for fname in TEMP_FILES:
data_path = os.path.join(DIR_TEMP, fname)
data = read_file(data_path)
path = os.path.join(dir_temp, fname)
if write_file(path, data):
logger.debug(msg.PROC_MESSAGE.format(proc=f"Create {path}"))
else:
logger.warning(
msg.ERR_FAIL_CANNOT_WRITE_DATA.format(data=f"{path}"))
return False
return True
def nametags_from(assets: AssetsDB) -> dict:
assert isinstance(assets, AssetsDB)
logger.debug(msg.PROC_START.format(proc=PROC))
config = yaml.safe_load(read_file(FILE_CONFIG))
if not config:
logger.error(msg.ERR_FAIL_MISSING_DATA.format(data=f"config file: {PROC}"))
return {}
mob_num = config[ELM_CONFIG][ELM_MOBS]
tmp = {}
for key, val in assets.data.items():
assert isinstance(key, str)
assert isinstance(val, SObject)
if isinstance(val, Person):
if not Converter.person_names_of(tmp, val):
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"person '{val.tag}' name: {PROC}"))
elif isinstance(val, Stage):
if not Converter.stage_names_of(tmp, val):
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"stage '{val.tag}' name: {PROC}"))
elif isinstance(val, Item):
if not Converter.item_name_of(tmp, val):
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"item '{val.tag}' name: {PROC}"))
elif isinstance(val, NameTag):
if NameTagType.MOB is val.type:
if not Converter.mob_name_of(tmp, val, mob_num):
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"mob names: {PROC}"))
elif NameTagType.TIME is val.type:
if not Converter.time_name_of(tmp, val):
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"time names: {PROC}"))
elif NameTagType.WORD is val.type:
if not Converter.word_name_of(tmp, val):
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"word names: {PROC}"))
else:
continue
elif isinstance(val, Rubi):
continue
else:
continue
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return tmp
