def ba_bear(adventure):
if random.random() < 0.4:
battle.qsab(adventure, Location.FOREST, 'D', icon=Emoji.BEAR,
pre_text=[tr(adventure.get_lang(), 'FOREST.EVENT2')])
else:
battle.qsab(adventure, Location.FOREST, 'A')
b_reward(adventure)
async def start_adventure(cmd: Command, location: str):
if location in adventure_provider.name_to_adventure:
await adventure_provider.name_to_adventure[location].start(
cmd, [cmd.user])
else:
await cmd.send_hidden(
tr(cmd.lang, 'COMMANDS.ADVENTURE.UNKNOWN', location=location))
def ab_continue_path(adventure):
if random.random() < 0.5:
bc = BonusChapter(tr(adventure.get_lang(), 'FOREST.EVENT3'))
bc.add_modifier(StatModifier(Stat.DEF, 3, StatModifierOperation.ADD))
adventure.add_chapter(bc)
else:
bc = BonusChapter(tr(adventure.get_lang(), 'FOREST.EVENT4'))
bc.add_persistent(Stat.HP, Stat.HP.get_value(2))
adventure.add_chapter(bc)
battle.qsab(adventure, Location.FOREST, 'A')
battle.qsab(adventure, Location.FOREST, 'C')
if random.random() < 0.5:
adventure.add_chapter(MoneyRewardChapter(random.randint(100, 150)))
else:
item: Equipment = RandomEquipmentBuilder(0).set_location(Location.ANYWHERE) \
.choose_rarity([ItemRarity.UNCOMMON, ItemRarity.RARE, ItemRarity.EPIC], [6, 3, 1]).build()
adventure.add_chapter(ItemRewardChapter(item))
async def reward(self):
user: User = random.choice(self.get_adventure().get_users())
if len(self.get_adventure().get_users()) == 1:
await self.send_log(
tr(self.get_lang(),
'REWARD.MONEY_YOU',
money=utils.print_money(self.get_lang(), self.money)))
else:
await self.send_log(
tr(self.get_lang(),
'REWARD.MONEY_SOMEONE',
money=utils.print_money(self.get_lang(), self.money),
name=user.get_name()))
user.add_money(self.money)
await self.end()
def use(lang: str, source: 'BattleEntity', target_entity: 'BattleEntity',
tier: int) -> str:
bot_entity: 'BotEntity' = enemy_utils.get_enemy(
SUMMON_TYPES_TIER[tier][0]).instance()
source.get_group().add_entity(bot_entity)
return tr(lang,
'ABILITIES.SUMMON',
source=source.get_name(),
summon=bot_entity.get_name())
def print_int(lang: str, number: int) -> str:
if number < 0:
return '-' + print_int(lang, -number)
result = ''
thousand_sep = tr(lang, 'MISC.THOUSAND_SEP')
while number >= 1000:
number, r = divmod(number, 1000)
result = "%s%03d%s" % (thousand_sep, r, result)
return "%d%s" % (number, result)
def mushroom_effect(adventure: Adventure):
bc = BonusChapter(tr(adventure.get_lang(), 'FOREST.EVENT6'))
if color == 0:
bc.add_modifier(StatModifier(Stat.DEF, -2, StatModifierOperation.ADD, 1))
elif color == 1:
bc.add_modifier(StatModifier(Stat.SPD, 5, StatModifierOperation.ADD))
else:
bc.add_persistent(Stat.HP, Stat.HP.get_value(4))
adventure.insert_chapter(bc)
def ba_pick(adventure: Adventure):
if random.random() < 0.5:
bc: BonusChapter = BonusChapter(
tr(adventure.get_lang(), 'LAKE.DECISION2_RESULT1'))
if random.random() < 0.5:
bc.add_modifier(
StatModifier(Stat.STR, 2, StatModifierOperation.ADD))
else:
bc.add_modifier(
StatModifier(Stat.DEF, 2, StatModifierOperation.ADD))
adventure.add_chapter(bc)
battle.qsab(adventure, Location.LAKE, 'A')
else:
battle.qsab(
adventure,
Location.LAKE,
'B',
pre_text=[tr(adventure.get_lang(), 'LAKE.DECISION2_RESULT2')])
b_before_reward(adventure)
async def check(cmd: Command, user: discord.Member):
if user.id in [824935594509336576, 824720383596560444]:
await cmd.send("._.")
return
user_m = storage.get_user(cmd.db, user.id, False)
if not user_m:
await cmd.send_hidden(tr(cmd.lang, 'COMMAND.CHECK.NO_INTERACTION'))
return
await cmd.send(user_m.print(cmd.lang, private=False, checking=True))
def use(lang: str, source: 'BattleEntity', target_entity: 'BattleEntity',
tier: int) -> str:
target_entity.add_temp_modifier(
StatModifier(Stat.DEF, -3, StatModifierOperation.ADD, 3))
target_entity.add_temp_modifier(
StatModifier(Stat.STR, -4, StatModifierOperation.ADD, 3))
return tr(lang,
'ABILITIES.CLAW_USE',
source=source.get_name(),
target=target_entity.get_name())
async def check(cmd: Command):
money = cmd.guild.get_box()
if money == 0:
await cmd.send_hidden(tr(cmd.lang, 'CRATE.EMPTY', EMOJI_BOX=Emoji.BOX))
else:
rate_str = cmd.guild.print_box_rate()
if len(rate_str) > 0:
await cmd.send(
tr(cmd.lang,
'CRATE.SHOW_RATE',
money=utils.print_money(cmd.lang, money),
EMOJI_BOX=Emoji.BOX,
EMOJI_CLOCK=Emoji.CLOCK,
rate=rate_str))
else:
await cmd.send(
tr(cmd.lang,
'CRATE.SHOW',
money=utils.print_money(cmd.lang, money),
EMOJI_BOX=Emoji.BOX))
def aa_deepest(adventure: Adventure):
battle.qsab(adventure, Location.LAKE, 'C')
battle.qsab(adventure, Location.LAKE, 'C')
bc: BonusChapter = BonusChapter(tr(adventure.get_lang(), 'LAKE.EVENT2'))
bc.add_persistent(Stat.HP, 20)
adventure.add_chapter(bc)
ability_ai: AbilityAI = AbilityAI(
[AbilityDecision(0, 1, AbilityContainer(AbilityEnum.CLAW, 0))])
boss: BotEntity = battle.rnd(adventure, Location.LAKE, 'BOSS', ability_ai)
battle.qsbb(adventure,
boss,
icon=Emoji.WAVES,
pre_text=[
tr(adventure.get_lang(), 'LAKE.BOSS1'),
tr(adventure.get_lang(), 'LAKE.BOSS2'),
tr(adventure.get_lang(), 'LAKE.BOSS3')
])
item: Equipment = RandomEquipmentBuilder(0).set_location(
Location.LAKE).build()
adventure.add_chapter(ItemRewardChapter(item))
async def reward(self):
users: list[User] = [
user for user in self.get_adventure().get_users()
if user.inventory.get_empty_slot(SlotType.ITEMS) is not None
]
if not users:
users = self.get_adventure().get_users()
user: User = random.choice(users)
slot: Optional[str] = user.inventory.get_empty_slot(SlotType.ITEMS)
if slot is not None:
user.inventory.add_item(self.item, slot)
if len(self.get_adventure().get_users()) == 1:
await self.send_log(
tr(self.get_lang(),
'REWARD.ITEM_YOU',
item=self.item.print()))
else:
await self.send_log(
tr(self.get_lang(),
'REWARD.ITEM_SOMEONE',
item=self.item.print(),
name=user.get_name()))
else:
money = Shop.get_sell_price(self.item)
user.add_money(money)
if len(self.get_adventure().get_users()) == 1:
await self.send_log(
tr(self.get_lang(),
'REWARD.ITEM_SOLD_YOU',
item=self.item.print(),
money=utils.print_money(self.get_lang(), money)))
else:
await self.send_log(
tr(self.get_lang(),
'REWARD.ITEM_SOLD_SOMEONE',
item=self.item.print(),
name=user.get_name(),
money=utils.print_money(self.get_lang(), money)))
await self.end()
def a_deep(adventure: Adventure):
battle.qsab(adventure, Location.LAKE, 'B')
battle.qsab(adventure, Location.LAKE, 'B')
bc: BonusChapter = BonusChapter(tr(adventure.get_lang(), 'LAKE.EVENT1'))
if random.random() < 0.5:
bc.add_modifier(StatModifier(Stat.EVA, 3, StatModifierOperation.ADD))
else:
bc.add_modifier(StatModifier(Stat.CONT, 4, StatModifierOperation.ADD))
bc.add_persistent(Stat.HP, 4)
adventure.add_chapter(bc)
adventure.add_chapter(
ChoiceChapter(Emoji.LAKE,
tr(adventure.get_lang(),
'LAKE.DECISION3_TEXT')).add_choice(
Emoji.UP,
tr(adventure.get_lang(),
'LAKE.DECISION3_OPTION1'),
aa_deepest).add_choice(
Emoji.RIGHT,
tr(adventure.get_lang(),
'LAKE.DECISION3_OPTION2'), ab_around))
def _print_round(self) -> str:
mult: int = self._get_mulitplier()
ret_txt: str
if self._round == 0:
ret_txt = tr(self.get_lang(),
'BATTLE.LOADING',
EMOJI_BATTLE=Emoji.BATTLE)
elif mult == 1:
ret_txt = tr(self.get_lang(),
'BATTLE.ROUND',
EMOJI_BATTLE=Emoji.BATTLE,
round=self._round)
else:
ret_txt = tr(self.get_lang(),
'BATTLE.ROUND_DMG',
EMOJI_BATTLE=Emoji.BATTLE,
round=self._round,
multiplier=mult)
if self._multiple_users:
ret_txt += f" {Emoji.CLOCK} {utils.print_time(self.get_lang(), BattleChapter.MULTI_PLAYER_DELAY)}"
return ret_txt
def print_progress(self, current_chapter: Optional['Chapter']) -> str:
path: list[str] = []
if current_chapter is None:
path.append(Emoji.COWBOY.value)
else:
path.append(f"{Emoji.COWBOY}{current_chapter.icon}")
for chapter in self._chapters:
if not chapter.hidden:
path.append(chapter.icon.value)
return tr(self._lang,
"ADVENTURE.PROGRESS",
icon=self._instance.icon,
progress=' ⎯ '.join(path))
async def menu(cmd: Command):
tp = [
"```fix",
format_row([
tr(cmd.lang, 'UPGRADE.UPGRADE_NAME'),
tr(cmd.lang, 'UPGRADE.LEVEL'),
tr(cmd.lang, 'UPGRADE.CURRENT'),
tr(cmd.lang, 'UPGRADE.UPGRADE_COST'),
tr(cmd.lang, 'UPGRADE.NEXT_VALUE')
]),
format_row([
'----------------------', '-------', '----------------',
'--------------', '----------------'
]),
custom_print(cmd.lang, cmd.user.upgrades['money'],
print_money_wrapper(cmd.lang)),
custom_print(cmd.lang, cmd.user.upgrades['bank'],
print_money_wrapper(cmd.lang)),
custom_print(cmd.lang, cmd.user.upgrades['garden'],
rate_hour_wrapper(cmd.lang)),
custom_print(cmd.lang, cmd.user.upgrades['inventory']), '```'
]
await cmd.send_hidden('\n'.join(tp))
async def place(cmd: Command, money: int):
if money < Guild.TABLE_MIN:
await cmd.error(
tr(cmd.lang,
'CRATE.MIN',
money=utils.print_money(cmd.lang, Guild.TABLE_MIN)))
return
placed = cmd.guild.place_box(cmd.user, money)
if placed:
rate_str = cmd.guild.print_box_rate()
await cmd.send(
tr(cmd.lang,
'CRATE.PLACE',
EMOJI_BOX=Emoji.BOX,
name=cmd.user.get_name(),
money=utils.print_money(cmd.lang, money),
rate=rate_str,
EMOJI_CLOCK=Emoji.CLOCK))
else:
await cmd.error(
tr(cmd.lang,
'CRATE.LACK',
money=utils.print_money(cmd.lang, money)))
async def short_menu(cmd: Command):
tp = [
tr(cmd.lang, 'UPGRADE.AVAILABLE'),
custom_print(cmd.lang,
cmd.user.upgrades['money'],
print_money_wrapper(cmd.lang),
mobile=True),
custom_print(cmd.lang,
cmd.user.upgrades['bank'],
print_money_wrapper(cmd.lang),
mobile=True),
custom_print(cmd.lang,
cmd.user.upgrades['garden'],
rate_hour_wrapper(cmd.lang),
mobile=True),
custom_print(cmd.lang, cmd.user.upgrades['inventory'], mobile=True),
]
await cmd.send_hidden('\n'.join(tp))
async def duel(cmd: Command, user: discord.Member):
if user.id in [824935594509336576, 824720383596560444]:
await cmd.send_hidden("Sure, bring it on.")
await adventure_provider.quick_adventure(
cmd, [cmd.user], 'Tim Lord Duel', Emoji.DEAD, 0, [
BattleChapter(
BattleGroup(users=[cmd.user]),
BattleGroup([
enemy_utils.get_random_enemy(Location.NOWHERE,
'TIM').instance()
]))
])
return
user_m = storage.get_user(cmd.db, user.id, False)
user_m.member = user
if not user_m:
await cmd.send_hidden(tr(cmd.lang, 'COMMAND.CHECK.NO_INTERACTION'))
return
await adventure_provider.name_to_adventure['_duel'].start(
cmd, [cmd.user], {'duel_user': user_m})
def print(self, lang: str, private=True, checking=False) -> str:
to_print = []
if checking:
to_print.append(tr(lang, 'USER.PROFILE', name=self.get_name()))
if private:
to_print.append(
f"{Emoji.MONEY} Money: {utils.print_money(lang, self.get_money())} "
f"/ {utils.print_money(lang, self.get_money_limit())}")
to_print.append(
f"{Emoji.BANK} Bank: {utils.print_money(lang, self.get_bank())} "
f"/ {utils.print_money(lang, self.get_bank_limit())} "
f"({self.print_garden_rate()} {Emoji.GARDEN})")
if self.get_tokens() >= self.get_token_limit():
to_print.append(
f"{Emoji.TOKEN} Tokens: {self.get_tokens()} / {self.get_token_limit()}"
)
else:
to_print.append(
f"{Emoji.TOKEN} Tokens: {self.get_tokens()} / {self.get_token_limit()} "
f"(Next in "
f"{utils.print_time(self.get_lang(), self._tokens.get_until(self.get_tokens() + 1))})"
)
if checking:
to_print.append(
f"{Emoji.STATS} Equipment Power: {self.user_entity.get_power()}"
)
to_print.append(self.inventory.print(self.get_lang()))
else:
to_print.append(
f"{Emoji.MONEY} Money: {utils.print_money(lang, self.get_money())}"
)
to_print.append(
f"{Emoji.SCROLL} Average Level: {self.get_average_level()}")
to_print.append(
f"{Emoji.STATS} Equipment Power: {self.user_entity.get_power()}"
)
return '\n'.join(to_print)
def rhw(value):
t: str = tr(lang,
'MISC.RATE',
amount=utils.print_money(lang, value),
time=utils.TimeMetric.HOUR.abbreviation(lang))
return f"+{t}"
async def start(self, cmd: 'Command', users: list[User]):
assert len(
self._chapters) > 0, "Tried starting adventure without chapters"
assert len(users) > 0, "Tried starting adventure without chapters"
self._lang = cmd.lang
self._started_on = utils.now()
have_tokens: bool = True
for user in users:
if user.get_tokens() < self._instance.tokens:
have_tokens = False
break
if not have_tokens:
if len(users) == 1:
await cmd.error(
tr(self._lang,
"ADVENTURE.NO_TOKENS_SINGLE",
tokens=self._instance.tokens,
EMOJI_TOKEN=Emoji.TOKEN))
else:
await cmd.error(
tr(self._lang,
"ADVENTURE.NO_TOKENS_MULTIPLE",
names=', '.join([x.get_name() for x in users]),
tokens=self._instance.tokens,
EMOJI_TOKEN=Emoji.TOKEN))
return
self._users = {user: UserAdventureData(user) for user in users}
for user in users:
user.remove_tokens(self._instance.tokens)
user.start_adventure(self)
message: Message
if self.start_override_text is not None:
message = await cmd.send(self.start_override_text + "\n" +
self.print_progress(None))
else:
message = await cmd.send(
tr(self._lang,
"ADVENTURE.START",
players=self.get_user_names(),
name=tr(self._lang, self._instance.name)) + "\n" +
self.print_progress(None))
self._message = messages.register_message_reactions(
message, {user.id
for user in self._users})
await asyncio.sleep(2)
while self._chapters:
chapter: Chapter = self._chapters.pop(0)
chapter.setup(self, self.print_progress(chapter))
await chapter.init()
await self._event.wait()
if self.lost:
await self.finish(lost=True)
return
self._event.clear()
await self.finish(lost=False)
def try_perform_action(self, battle_emoji: BattleEmoji, data: BattleActionData) -> Optional[str]:
target_entity: Optional[BattleEntity] = data.target_entity
if battle_emoji == BattleEmoji.ATTACK:
if target_entity is not None:
temp: str
ar: AttackResult = self.attack(data)
# Return message
msg = []
if ar.eva:
temp = tr(data.lang, 'BATTLE_ATTACK.EVADE', source=self.get_name(),
target=target_entity.get_name())
msg.append(f"> {Emoji.EVA} {temp}")
else:
if ar.vamp:
if ar.crit:
temp = tr(data.lang, 'BATTLE_ATTACK.CRITICAL_VAMP', source=self.get_name(),
target=target_entity.get_name(), damage=ar.damage)
msg.append(f"> {Emoji.CRIT}{Emoji.VAMP} {temp}")
else:
temp = tr(data.lang, 'BATTLE_ATTACK.VAMP', source=self.get_name(),
target=target_entity.get_name(), damage=ar.damage)
msg.append(f"> {Emoji.VAMP} {temp}")
else:
if ar.crit:
temp = tr(data.lang, 'BATTLE_ATTACK.CRIT', source=self.get_name(),
target=target_entity.get_name(), damage=ar.damage)
msg.append(f"> {Emoji.CRIT} {temp}")
else:
temp = tr(data.lang, 'BATTLE_ATTACK.ATTACK', source=self.get_name(),
target=target_entity.get_name(), damage=ar.damage)
msg.append(f"> {Emoji.BATTLE} {temp}")
if ar.counter is not None:
temp = tr(data.lang, 'BATTLE_ATTACK.COUNTER', target=target_entity.get_name(), damage=ar.damage)
msg.append(f"> {Emoji.CONT} {temp}")
return '\n'.join(msg)
if battle_emoji == BattleEmoji.POTION:
if self.is_user():
potion: Optional[Potion] = self._user.inventory.get_potion()
if potion is not None:
self._user.inventory.use_potion()
for sm in potion.copy_stat_modifiers():
self._user.user_entity.add_modifier(sm)
return f"{self._user.get_name()} used {potion.print()}!"
return None
if battle_emoji == BattleEmoji.WAIT:
return f"> {battle_emoji} {tr(data.lang, 'BATTLE_ATTACK.WAIT', source=self.get_name())}"
spell_index: int = battle_emoji.get_spell_index()
if 0 <= spell_index < len(self.get_abilities()) or (data.override_ability is not None):
ability_holder: AbilityContainer
if data.override_ability is None:
ability_holder = self.get_abilities()[spell_index]
else:
ability_holder = data.override_ability
if (target_entity is None) and ability_holder.ability.allow_self():
target_entity = self
if target_entity is None:
return None
if not self.use_ap(ability_holder.get_cost()):
return None
ret: str = f"> {battle_emoji} {ability_holder.use(data.lang, self, target_entity)}"
if ability_holder.get_duration() > 0:
target_entity.add_ability_instance(AbilityInstance(ability_holder))
start: str = ability_holder.start(data.lang, target_entity)
if start:
ret += f"\n> {ability_holder.get_icon()} {start}"
return ret
return None
def tr(self, lang: str):
return translate.tr(lang, self.message, **self._kwargs)
def get_name(self, lang: str) -> str:
return tr(lang, f"CLASS.{self.value.name}")
async def init(self) -> None:
if self._override_str:
await self.send_log(self._override_str)
else:
await self.send_log(tr(self.get_lang(), 'REWARD.BOX'))
await self.get_adventure().add_reaction(Emoji.BOX, self.reward)
async def setup(_: 'Command', adventure: Adventure):
battle.qsab(adventure, Location.FOREST, 'A')
battle.qsab(adventure, Location.FOREST, 'A')
adventure.add_chapter(ChoiceChapter(Emoji.GARDEN, tr(adventure.get_lang(), 'FOREST.DECISION1_TEXT'))
.add_choice(Emoji.UP, tr(adventure.get_lang(), 'FOREST.DECISION1_OPTION1'), a_deep)
.add_choice(Emoji.RIGHT, tr(adventure.get_lang(), 'FOREST.DECISION1_OPTION2'), b_around))
async def update(self, final: bool = False):
current_team: BattleGroup = self._get_current_team()
other_team: BattleGroup = self._get_opposing_team()
self.clear_log()
self.start_log()
if self._round < 2:
if self._pre_text:
self.add_log('\n'.join([f"_{x}_" for x in self._pre_text]))
if self._is_boss:
self.add_log(f"**{tr(self.get_lang(), 'BATTLE.BOSS_START')}**")
else:
self.add_log(f"{tr(self.get_lang(), 'BATTLE.START')}")
self.add_log(self._print_round())
for battle_entity in current_team.get_battle_entities():
self.add_log(battle_entity.print())
if self._get_current_team().get_alive_user_count() > 0:
if len(self._available_targets) == 1:
for battle_entity in other_team.get_battle_entities():
self.add_log(f"{battle_entity.print()}")
else:
td: dict[BattleEntity, list[str]] = {}
for be1, be2 in self._chosen_targets.items():
if be2 is not None:
td[be2] = td.get(be2, []) + [be1.get_name()]
for battle_entity in other_team.get_battle_entities():
if battle_entity in self._available_targets:
index: int = self._available_targets.index(
battle_entity)
sl: list[str] = td.get(battle_entity, [])
if sl and (not battle_entity.is_dead()):
self.add_log(
f"{index + 1} | {battle_entity.print()} <- {', '.join(sl)}"
)
else:
self.add_log(
f"{index + 1} | {battle_entity.print()}")
else:
self.add_log(f"{battle_entity.print()}")
else:
for battle_entity in other_team.get_battle_entities():
self.add_log(f"{battle_entity.print()}")
self.add_log('\n'.join(self._battle_log))
if not final:
if self._speed_balance == 0:
if self._group_a.get_speed() > self._group_b.get_speed():
self.add_log(
tr(self.get_lang(),
'BATTLE.SPEED_BONUS',
EMOJI_SPD=Emoji.SPD,
name=self._group_a.get_name(),
value='0%'))
elif self._group_a.get_speed() < self._group_b.get_speed():
self.add_log(
tr(self.get_lang(),
'BATTLE.SPEED_BONUS',
EMOJI_SPD=Emoji.SPD,
name=self._group_b.get_name(),
value='0%'))
else:
self.add_log(
tr(self.get_lang(),
'BATTLE.NO_SPEED_BONUS',
EMOJI_SPD=Emoji.SPD))
else:
if self._speed_balance > 0:
self.add_log(
tr(self.get_lang(),
'BATTLE.SPEED_BONUS',
EMOJI_SPD=Emoji.SPD,
name=self._group_a.get_name(),
value=f"{self._speed_balance:.0%}"))
else:
self.add_log(
tr(self.get_lang(),
'BATTLE.SPEED_BONUS',
EMOJI_SPD=Emoji.SPD,
name=self._group_b.get_name(),
value=f"{-self._speed_balance:.0%}"))
await self.send_log()
def print_money(lang: str, money: int):
money_str: str = print_int(lang, money)
return tr(lang, 'MISC.MONEY', number=money_str)
