def embed(state: TransformInfoViewState):
base_mon = state.base_mon
transformed_mon = state.transformed_mon
fields = [
EmbedField(
'/'.join(['{}'.format(t.name) for t in transformed_mon.types]),
Box(
IdView.normal_awakenings_row(transformed_mon)
if len(transformed_mon.awakenings) != 0 else Box(
Text('No Awakenings')), base_info(base_mon)),
),
EmbedField('Card info',
IdView.misc_info(transformed_mon,
state.true_evo_type_raw,
state.acquire_raw, state.base_rarity),
inline=True),
EmbedField(IdView.stats_header(transformed_mon).to_markdown(),
IdView.stats(transformed_mon),
inline=True),
EmbedField(
IdView.active_skill_header(transformed_mon).to_markdown() +
base_skill(base_mon),
Text(transformed_mon.active_skill.desc if transformed_mon.
active_skill else 'None')),
EmbedField(
IdView.leader_skill_header(transformed_mon).to_markdown(),
Text(transformed_mon.leader_skill.desc if transformed_mon.
leader_skill else 'None'))
]
return EmbedView(EmbedMain(
color=state.color,
title=MonsterHeader.long_v2(transformed_mon).to_markdown(),
url=puzzledragonx(transformed_mon)),
embed_thumbnail=EmbedThumbnail(
MonsterImage.icon(transformed_mon)),
embed_footer=pad_info_footer_with_state(state),
embed_fields=fields)
def embed(cls, state: IdViewState):
m = state.monster
fields = [
EmbedField(
'/'.join(['{}'.format(t.name) for t in m.types]),
Box(IdView.all_awakenings_row(m, state.transform_base),
cls.killers_row(m, state.transform_base))),
EmbedField(
'Inheritable' if m.is_inheritable else 'Not inheritable',
IdView.misc_info(m, state.true_evo_type_raw, state.acquire_raw,
state.base_rarity),
inline=True),
EmbedField(IdView.stats_header(m, state.previous_evolutions,
state.query_settings).to_markdown(),
IdView.stats(m, state.previous_evolutions,
state.query_settings),
inline=True),
EmbedField(
cls.active_skill_header(
m, state.previous_transforms).to_markdown(),
Text(
cls.active_skill_text(m.active_skill,
state.awoken_skill_map))),
EmbedField(
cls.leader_skill_header(m, state.query_settings.lsmultiplier,
state.transform_base).to_markdown(),
Text(m.leader_skill.desc if m.leader_skill else 'None')),
cls.evos_embed_field(state)
]
return EmbedView(EmbedMain(
color=state.color,
title=MonsterHeader.fmt_id_header(
m, state.alt_monsters[0].monster.monster_id == cls.TSUBAKI,
state.is_jp_buffed).to_markdown(),
url=puzzledragonx(m)),
embed_thumbnail=EmbedThumbnail(MonsterImage.icon(m)),
embed_footer=embed_footer_with_state(state),
embed_fields=fields)
def embed(cls, state: ClosableEmbedViewState, props: ShowStatsViewProps):
fields = []
for mon, c in Counter(props.valid).most_common(
cls.MAX_EXPANDED_RESULTS if len(props.valid) ==
cls.MAX_EXPANDED_RESULTS else cls.MAX_EXPANDED_RESULTS - 1):
fields.append(
EmbedField(
mon.name_en,
Box(
LabeledText("Net",
ShowStatsView.get_count(props.total, mon)),
LabeledText("Adj",
ShowStatsView.get_count(props.adj, mon)),
LabeledText("You",
ShowStatsView.get_count(props.you, mon))),
inline=True))
if len(props.valid) > cls.MAX_EXPANDED_RESULTS:
fields.append(
EmbedField(
"... & More",
Box(f"+ {len(props.valid)-cls.MAX_EXPANDED_RESULTS-1} more monsters"
),
inline=True))
return EmbedView(EmbedMain(
title=f"AdPEM Data for query: {state.raw_query}",
description=Box(
LabeledText("Net",
ShowStatsView.get_count(props.total,
*props.valid)),
LabeledText("Adj",
ShowStatsView.get_count(props.adj, *props.valid)),
LabeledText("You",
ShowStatsView.get_count(props.you,
*props.valid)))),
embed_thumbnail=EmbedThumbnail(
MonsterImage.icon(props.most_commmon)),
embed_fields=fields,
embed_footer=embed_footer_with_state(state))
def embed(cls, state: EvosViewState):
fields = [
EmbedField(
("{} evolution" if len(state.alt_versions) == 1 else "{} evolutions").format(len(state.alt_versions)),
Box(*EvosView._evo_lines(state.alt_versions, state.monster)))]
if state.gem_versions:
fields.append(
EmbedField(
("{} evolve gem" if len(state.gem_versions) == 1 else "{} evolve gems").format(
len(state.gem_versions)),
Box(*EvosView._evo_lines(state.gem_versions, state.monster))))
return EmbedView(
EmbedMain(
color=state.color,
title=MonsterHeader.fmt_id_header(state.monster,
state.alt_monsters[0].monster.monster_id == cls.TSUBAKI,
state.is_jp_buffed).to_markdown(),
url=puzzledragonx(state.monster)),
embed_thumbnail=EmbedThumbnail(MonsterImage.icon(state.monster)),
embed_footer=embed_footer_with_state(state),
embed_fields=fields)
def embed(cls, state: MaterialsViewState):
# m: "MonsterModel", color, mats, usedin, gemid, gemusedin, skillups, skillup_evo_count, link
return EmbedView(
EmbedMain(
color=state.color,
title=MonsterHeader.fmt_id_header(state.monster,
state.alt_monsters[0].monster.monster_id == cls.TSUBAKI,
state.is_jp_buffed).to_markdown(),
url=puzzledragonx(state.monster)
),
embed_thumbnail=EmbedThumbnail(MonsterImage.icon(state.monster)),
embed_footer=embed_footer_with_state(state),
embed_fields=[f for f in [
mat_use_field(state.mats, "Evo materials")
if state.mats or not (state.monster.is_stackable or state.gem_override) else None,
mat_use_field(state.usedin, "Material for", 10)
if state.usedin else None,
mat_use_field(state.gemusedin, "Evo gem ({}) is mat for".format(state.gemid),
10 if state.gem_override else 5)
if state.gemusedin else None,
skillup_field(state.skillups, state.skillup_evo_count, state.link)
if not (state.monster.is_stackable or state.gem_override) else None
] if f is not None] + [cls.evos_embed_field(state)]
)
def embed(state, props: ExperienceCurveViewProps):
regular = get_normal_exp_difference(props.monster, props.low,
props.high, props.offset)
lb = get_lb_exp_difference(props.monster, props.low, props.high,
props.offset)
slb = get_slb_exp_difference(props.monster, props.low, props.high,
props.offset)
is_light = props.monster.full_damage_attr.value == 3
return EmbedView(
EmbedMain(
color=state.color,
title=MonsterHeader.fmt_id_header(props.monster,
use_emoji=True),
url=puzzledragonx(props.monster),
description=Text(f'lv{props.low} -> lv{props.high} (' +
(trunc_humanize(props.monster.exp_curve)
if props.monster.exp_curve else "no") +
f' curve)'),
),
embed_thumbnail=EmbedThumbnail(MonsterImage.icon(props.monster)),
embed_fields=[
EmbedField(title='Exact',
body=Box(
LabeledText("Reg", humanize_number(regular)),
LabeledText("LB", humanize_number(lb)),
LabeledText("SLB", humanize_number(slb)),
LabeledText("Net",
humanize_number(regular + lb +
slb))),
inline=True),
EmbedField(title='Approx',
body=Box(
LabeledText("Reg", trunc_humanize(regular)),
LabeledText("LB", trunc_humanize(lb)),
LabeledText("SLB", trunc_humanize(slb)),
LabeledText("Net",
trunc_humanize(regular + lb +
slb))),
inline=True),
EmbedField(
title='Resources',
body=Box(
LabeledText(
"Globes " + emoji_cache.get_emoji(
f'orb_{props.monster.full_damage_attr.name.lower()}'
),
str(
get_total_needed(
props.monster, props.low, props.high,
props.offset,
ceil(1.5 * GLOBE_EXP[
props.monster.full_damage_attr.value]),
is_light))),
LabeledText(
"TA2",
str(
get_total_needed(props.monster, props.low,
props.high, props.offset,
TA2_EXP, is_light))),
LabeledText(
"TA3",
str(
get_total_needed(props.monster, props.low,
props.high, props.offset,
TA3_EXP, is_light))),
),
inline=True)
],
embed_footer=embed_footer_with_state(state))
async def guess(self, ctx, *, guess):
"""Guess a card for the daily PADle"""
if await self.do_quit_early(ctx):
return
dbcog = await self.get_dbcog()
guess_monster = await dbcog.find_monster(guess, ctx.author.id)
if guess_monster is None:
close_menu = ClosableEmbedMenu.menu()
props = PADleMonsterConfirmationViewProps(
"Monster not found, please try again.")
query_settings = await QuerySettings.extract_raw(
ctx.author, self.bot, guess)
state = ClosableEmbedViewState(
ctx.author.id, ClosableEmbedMenu.MENU_TYPE, guess,
query_settings, PADleMonsterConfirmationView.VIEW_TYPE, props)
await close_menu.create(ctx, state)
return
m_embed = EmbedView(EmbedMain(
title=MonsterHeader.menu_title(guess_monster).to_markdown(),
description="Did you mean this monster?"),
embed_thumbnail=EmbedThumbnail(
MonsterImage.icon(
guess_monster.monster_id))).to_embed()
confirmation = await get_user_reaction(ctx,
m_embed,
YES_EMOJI,
NO_EMOJI,
timeout=20)
if confirmation is None:
return await send_cancellation_message(ctx,
"Confirmation timeout.")
if confirmation == NO_EMOJI:
return await send_cancellation_message(ctx, "Please guess again.")
if not await self.config.user(ctx.author).start():
return await send_cancellation_message(
ctx,
"You have not started a game yet! The PADle may have just expired."
)
if await self.config.user(ctx.author).done():
return await send_cancellation_message(
ctx, "You have already finished today's PADle!")
async with self.config.user(
ctx.author).todays_guesses() as todays_guesses:
todays_guesses.append(guess_monster.monster_id)
monster = dbcog.get_monster(int(await self.config.padle_today()))
cur_day = await self.config.num_days()
todays_guesses = await self.config.user(ctx.author).todays_guesses()
async with self.config.user(ctx.author).all_guesses() as all_guesses:
all_guesses[str(cur_day)] = todays_guesses
channel = self.bot.get_channel(await self.config.user(ctx.author
).channel_id())
if channel is not None:
with suppress(discord.HTTPException):
del_msg = await channel.fetch_message(await self.config.user(
ctx.author).edit_id())
await del_msg.delete()
guess_monster_diff = MonsterDiff(monster, guess_monster)
points = guess_monster_diff.get_diff_score()
padle_menu = PADleScrollMenu.menu()
# query_settings = await QuerySettings.extract_raw(ctx.author, self.bot, guess)
cur_page = ceil(len(todays_guesses) / 5) - 1
page_guesses = await PADleScrollViewState.do_queries(
dbcog, todays_guesses[((cur_page) * 5):((cur_page + 1) * 5)])
state = PADleScrollViewState(ctx.author.id,
PADleScrollMenu.MENU_TYPE,
guess,
monster=monster,
cur_day_page_guesses=page_guesses,
current_day=cur_day,
current_page=cur_page,
num_pages=cur_page + 1)
message = await padle_menu.create(ctx, state)
await self.config.user(ctx.author).edit_id.set(message.id)
await self.config.user(ctx.author).channel_id.set(ctx.channel.id)
score = "\N{LARGE YELLOW SQUARE}"
if guess_monster.monster_id == monster.monster_id:
await ctx.send(
"You got the PADle in {} guesses! Use `{}padle score` to share your score."
.format(
len(await self.config.user(ctx.author).todays_guesses()),
ctx.prefix))
await self.config.user(ctx.author).done.set(True)
async with self.config.all_scores() as all_scores:
all_scores.append(
str(
len(await
self.config.user(ctx.author).todays_guesses())))
score = "\N{LARGE GREEN SQUARE}"
else:
if points < 9:
score = "\N{LARGE ORANGE SQUARE}"
if points < 5:
score = "\N{LARGE RED SQUARE}"
async with self.config.user(ctx.author).score() as scores:
scores.append(score)
def monster_thumbnail(m: "MonsterModel"):
return EmbedThumbnail(MonsterImage.icon(m))