def from_css(css: CrossServerSkill) -> 'ActiveSkill':
jp_skill = css.jp_skill
na_skill = css.na_skill
kr_skill = css.kr_skill
cur_skill = css.cur_skill
desc_ja = cur_skill.full_text(JaASTextConverter())
desc_en = cur_skill.full_text(EnASTextConverter())
desc_ko = cur_skill.full_text(KoASTextConverter())
desc_templated_ja = cur_skill.templated_text(JaASTextConverter())
desc_templated_en = cur_skill.templated_text(EnASTextConverter())
desc_templated_ko = cur_skill.templated_text(KoASTextConverter())
skill_type_tags = skill_text_typing.parse_as_conditions(css)
tags = skill_text_typing.format_conditions(skill_type_tags)
return ActiveSkill(
active_skill_id=jp_skill.skill_id,
compound_skill_type_id=cur_skill.compound_skill_type,
name_ja=jp_skill.name,
name_en=na_skill.name,
name_ko=kr_skill.name,
desc_ja=desc_ja,
desc_en=desc_en,
desc_ko=desc_ko,
desc_templated_ja=desc_templated_ja,
desc_templated_en=desc_templated_en,
desc_templated_ko=desc_templated_ko,
desc_official_ja=jp_skill.raw_description,
desc_official_en=na_skill.raw_description,
desc_official_ko=kr_skill.raw_description,
cooldown_turns_max=cur_skill.cooldown_turns_max,
cooldown_turns_min=cur_skill.cooldown_turns_min,
tags=tags)
def from_as(act: ASSkill) -> 'ActiveSubskill':
desc_ja = act.full_text(JaASTextConverter())
desc_en = act.full_text(EnASTextConverter())
desc_ko = act.full_text(KoASTextConverter())
desc_templated_ja = act.templated_text(JaASTextConverter())
desc_templated_en = act.templated_text(EnASTextConverter())
desc_templated_ko = act.templated_text(KoASTextConverter())
skill_type_tags = skill_text_typing.parse_as_conditions(act, True)
tags = skill_text_typing.format_conditions(skill_type_tags)
return ActiveSubskill(
active_subskill_id=act.skill_id,
# TODO: Figure out how to do names
name_ja="",
name_en="",
name_ko="",
desc_ja=desc_ja,
desc_en=desc_en,
desc_ko=desc_ko,
desc_templated_ja=desc_templated_ja,
desc_templated_en=desc_templated_en,
desc_templated_ko=desc_templated_ko,
board_65=act.board.to_6x5(),
board_76=act.board.to_7x6(),
cooldown=act.cooldown_turns_max or -1,
tags=tags)
def save_cross_database(output_dir: str, db: CrossServerDatabase):
raw_card_dir = os.path.join(output_dir, 'cards')
pathlib.Path(raw_card_dir).mkdir(parents=True, exist_ok=True)
for c in db.ownable_cards:
card_file = os.path.join(raw_card_dir, '{}.txt'.format(c.monster_id))
with open(card_file, 'w', encoding='utf-8') as f:
# Write top level info for the monster
f.write('#{} {}\n'.format(c.monster_id, c.na_card.card.name))
card_info = c.jp_card.card
f.write('HP: {} ATK: {} RCV: {} LB: {}\n'.format(card_info.max_hp,
card_info.max_atk,
card_info.max_rcv,
card_info.limit_mult))
f.write('AWK: {}\n'.format(','.join(map(str, card_info.awakenings))))
f.write('SAWK: {}\n'.format(','.join(map(str, card_info.super_awakenings))))
f.write('\n')
if c.active_skill:
dump_skill(f, c.active_skill, EnASTextConverter())
if c.leader_skill:
dump_skill(f, c.leader_skill, EnLSTextConverter())
as_file = os.path.join(output_dir, 'active_skills.txt')
with open(as_file, 'w', encoding='utf-8') as f:
converter = EnASTextConverter()
for css in db.active_skills:
dump_skill(f, css, converter)
ls_file = os.path.join(output_dir, 'leader_skills.txt')
with open(ls_file, 'w', encoding='utf-8') as f:
converter = EnLSTextConverter()
for css in db.leader_skills:
dump_skill(f, css, converter)
def from_css(css: CrossServerSkill) -> 'ActiveSkill':
jp_skill = css.jp_skill
na_skill = css.na_skill
kr_skill = css.kr_skill
jp_as_converter = JpASTextConverter()
ja_description = jp_skill.full_text(jp_as_converter)
en_as_converter = EnASTextConverter()
en_description = jp_skill.full_text(en_as_converter)
skill_type_tags = skill_text_typing.parse_as_conditions(css)
tags = skill_text_typing.format_conditions(skill_type_tags)
# In the event that we don't have KR data, use the NA name and calculated description.
kr_name = kr_skill.name if jp_skill != kr_skill else na_skill.name
ko_desc = kr_skill.raw_description if jp_skill != kr_skill else en_description
return ActiveSkill(active_skill_id=jp_skill.skill_id,
name_ja=jp_skill.name,
name_en=na_skill.name,
name_ko=kr_name,
desc_ja=ja_description,
desc_en=en_description,
desc_ko=ko_desc,
turn_max=jp_skill.turn_max,
turn_min=jp_skill.turn_min,
tags=tags)
def from_as(act: ASSkill) -> 'ActivePart':
desc_ja = act.full_text(JaASTextConverter())
desc_en = act.full_text(EnASTextConverter())
desc_ko = act.full_text(KoASTextConverter())
desc_templated_ja = act.templated_text(JaASTextConverter())
desc_templated_en = act.templated_text(EnASTextConverter())
desc_templated_ko = act.templated_text(KoASTextConverter())
skill_type_tags = skill_text_typing.parse_as_conditions(act, True)
tags = skill_text_typing.format_conditions(skill_type_tags)
return ActivePart(active_part_id=act.skill_id,
active_skill_type_id=act.skill_type,
desc_ja=desc_ja,
desc_en=desc_en,
desc_ko=desc_ko,
desc_templated_ja=desc_templated_ja,
desc_templated_en=desc_templated_en,
desc_templated_ko=desc_templated_ko,
tags=tags)
def print_translations(skill) -> None:
if isinstance(skill, ActiveSkill):
if args.show_en:
print("EN:", skill.text(EnASTextConverter()))
if args.show_ja:
print("JA:", skill.text(JaASTextConverter()))
if args.show_ko:
print("KO:", skill.text(KoASTextConverter()))
elif isinstance(skill, LeaderSkill):
if args.show_en:
print("EN:", skill.text(EnLSTextConverter()))
if args.show_ja:
print("JA:", skill.text(JaLSTextConverter()))
if args.show_ko:
print("KO:", skill.text(KoLSTextConverter()))
import argparse
import os
import pathlib
import padtools
from pad.common import pad_util
from pad.common.shared_types import Server
from pad.raw.skills import skill_text_typing
from pad.raw.skills.en.active_skill_text import EnASTextConverter
from pad.raw.skills.jp.active_skill_text import JpASTextConverter
from pad.raw.skills.en.leader_skill_text import EnLSTextConverter
from pad.raw.skills.jp.leader_skill_text import JpLSTextConverter
from pad.raw.skills.jp.enemy_skill_text import JpESTextConverter
from pad.raw.skills.en.enemy_skill_text import EnESTextConverter
from pad.raw.skills.leader_skill_info import LeaderSkill
AS_CONVERTERS = (JpASTextConverter(), EnASTextConverter(), EnASTextConverter())
LS_CONVERTERS = (JpLSTextConverter(), EnLSTextConverter(), EnLSTextConverter())
ES_CONVERTERS = (JpESTextConverter(), EnESTextConverter(), EnESTextConverter())
from pad.raw_processor import merged_database
from pad.raw_processor.crossed_data import CrossServerDatabase
from pad.raw.skills.enemy_skill_info import BEHAVIOR_MAP
def parse_args():
parser = argparse.ArgumentParser(description="Runs the integration test.",
add_help=False)
input_group = parser.add_argument_group("Input")
input_group.add_argument("--input_dir",
required=True,
help="Path to a folder where the input data is")
def load_text(self):
self.en_ls_text = self.leader_skill.jp_skill.full_text(
EnLSTextConverter()) if self.leader_skill else None
self.en_as_text = self.active_skill.jp_skill.full_text(
EnASTextConverter()) if self.active_skill else None
def __init__(self, jp_database: Database, na_database: Database,
kr_database: Database):
self.all_cards = build_cross_server_cards(
jp_database, na_database,
kr_database) # type: List[CrossServerCard]
self.ownable_cards = list(
filter(lambda c: 0 < c.monster_id < 19999,
self.all_cards)) # type: List[CrossServerCard]
self.leader_skills = build_cross_server_skills(
jp_database.leader_skills, na_database.leader_skills,
kr_database.leader_skills)
ls_converter = EnLSTextConverter()
for ls in self.leader_skills:
ls.en_text = ls.jp_skill.full_text(ls_converter)
ls.skill_type_tags = list(
skill_text_typing.parse_ls_conditions(ls.en_text))
ls.skill_type_tags.sort(key=lambda x: x.value)
self.active_skills = build_cross_server_skills(
jp_database.active_skills, na_database.active_skills,
kr_database.active_skills)
as_converter = EnASTextConverter()
for ask in self.active_skills:
ask.en_text = ask.jp_skill.full_text(as_converter)
ask.skill_type_tags = list(
skill_text_typing.parse_as_conditions(ask.en_text))
ask.skill_type_tags.sort(key=lambda x: x.value)
self.dungeons = build_cross_server_dungeons(
jp_database, na_database,
kr_database) # type: List[CrossServerDungeon]
self.enemy_skills = build_cross_server_enemy_skills(
jp_database.raw_enemy_skills, na_database.raw_enemy_skills,
kr_database.raw_enemy_skills)
self.jp_bonuses = jp_database.bonuses
self.na_bonuses = na_database.bonuses
self.kr_bonuses = kr_database.bonuses
self.jp_exchange = jp_database.exchange
self.na_exchange = na_database.exchange
self.kr_exchange = kr_database.exchange
self.jp_egg_machines = jp_database.egg_machines
self.na_egg_machines = na_database.egg_machines
self.kr_egg_machines = kr_database.egg_machines
self.jp_exchange = jp_database.exchange
self.na_exchange = na_database.exchange
self.kr_exchange = kr_database.exchange
self.monster_id_to_card = {c.monster_id: c for c in self.all_cards}
self.leader_id_to_leader = {s.skill_id: s for s in self.leader_skills}
self.active_id_to_active = {s.skill_id: s for s in self.active_skills}
self.dungeon_id_to_dungeon = {d.dungeon_id: d for d in self.dungeons}
self.hq_image_monster_ids = [] # type: List[MonsterId]
self.animated_monster_ids = [] # type: List[MonsterId]
for csc in self.ownable_cards:
if csc.leader_skill:
csc.leader_skill = self.leader_id_to_leader[
csc.leader_skill.skill_id]
if csc.active_skill:
csc.active_skill = self.active_id_to_active[
csc.active_skill.skill_id]
csc.load_text()
