def attack(self, mult, min_hit=1, max_hit=1):
if mult is None:
return None
output = '{}%데미지'. \
format(minmax(int(min_hit) * int(mult), int(max_hit) * int(mult)))
if min_hit and max_hit != 1:
output += ' ({}회, 각 {}%)'. \
format(minmax(min_hit, max_hit), mult)
return output
def attack(self, mult, min_hit=1, max_hit=1):
if mult is None:
return None
output = 'Deal {:s}% damage'. \
format(minmax(int(min_hit) * int(mult), int(max_hit) * int(mult)))
if min_hit and max_hit != 1:
output += ' ({:s}, {:,}% each)'. \
format(noun_count("hit", minmax(min_hit, max_hit)), mult)
return output
def absorb(self, abs_type: Absorb, condition, min_turns, max_turns=None):
if abs_type == Absorb.attr:
source = self.attributes_to_str(condition)
return '{}턴동안 {} 속성의 공격을 흡수' \
.format(minmax(min_turns, max_turns), source)
elif abs_type == Absorb.combo:
source = ' {}콤보 이하의'.format(condition)
elif abs_type == Absorb.damage:
source = ' {} 이상'.format(condition)
else:
source = 'ㅇㅇ'
return '{}턴동안 공격을 흡수'.format(minmax(min_turns, max_turns), source)
def recover(self,
min_amount,
max_amount,
target_type,
player_threshold=None):
target = targets_to_str([target_type])
if player_threshold and player_threshold != 100:
return capitalize_first(
'{:s} recover {:s} HP when below {}% HP'.format(
target, minmax(min_amount, max_amount, True),
player_threshold))
else:
return capitalize_first('{:s} recover {:s} HP'.format(
target, minmax(min_amount, max_amount, True)))
def absorb(self, abs_type: Absorb, condition, min_turns, max_turns=None):
if abs_type == Absorb.attr:
source = self.attributes_to_emoji(condition)
return "({}:{} for {})".format(emoji_dict['absorb'], source,
minmax(min_turns, max_turns))
elif abs_type == Absorb.combo:
return "({}{} for {})".format(emoji_dict['combo_absorb'],
condition,
minmax(min_turns, max_turns))
elif abs_type == Absorb.damage:
return "({}{} for {})".format(emoji_dict['damage_absorb'],
f'{condition:,}',
minmax(min_turns, max_turns))
else:
raise ValueError("unknown absorb type: {}".format(abs_type))
def recover(self,
min_amount,
max_amount,
target_type,
player_threshold=None):
target = targets_to_str([target_type])
if player_threshold and player_threshold != 100:
return "({}{}%HP{}{})".format(emoji_dict['recover'],
minmax(min_amount, max_amount),
emoji_dict['to'],
capitalize_first(target))
else:
return "({}{}%HP{}{})".format(emoji_dict['recover'],
minmax(min_amount, max_amount),
emoji_dict['to'],
capitalize_first(target))
def skyfall(self,
attributes,
chance,
min_turns,
max_turns=None,
locked=False):
lock = 'Locked ' if locked else ''
orbs = self.attributes_to_str(attributes)
# TODO: tieout
if lock and orbs == 'Random':
orbs = orbs.lower()
if not locked:
return "([{}:{}]+{}% for {})".format(
emoji_dict['skyfall'], self.attributes_to_emoji(attributes),
chance, minmax(min_turns, max_turns))
if locked:
return "([{}{}:{}]+{}% for {})".format(
emoji_dict['locked'], emoji_dict['skyfall'],
self.attributes_to_emoji(attributes), chance,
minmax(min_turns, max_turns))
def skyfall(self,
attributes,
chance,
min_turns,
max_turns=None,
locked=False):
lock = 'Locked ' if locked else ''
orbs = self.attributes_to_str(attributes)
if orbs != 'Random':
orbs += '드롭이 '
return '{}턴동안 {}%확률로 {}잠금 상태로 출현' \
.format(minmax(min_turns, max_turns), chance, orbs)
def bind(self,
min_turns,
max_turns,
target_count=None,
target_types=TargetType.card,
source: Source = None):
if isinstance(target_types, TargetType):
target_types = [target_types]
elif source is not None:
target_types = SOURCE_FUNCS[source]([target_types]) + ' cards'
targets = targets_to_str(target_types)
output = 'Bind {:s} '.format(noun_count(targets, target_count))
output += 'for ' + noun_count('turn', minmax(min_turns, max_turns))
return output
def bind(self,
min_turns,
max_turns,
target_count=None,
target_types=TargetType.card,
source: Source = None):
if isinstance(target_types, TargetType):
target_types = [target_types]
elif source is not None:
target_types = SOURCE_FUNCS[source]([target_types]) + ' cards'
targets = targets_to_str(target_types)
output = '({} {} '.format(emoji_dict['bind'],
noun_count(targets, target_count))
output += 'for ' + minmax(min_turns, max_turns) + ')'
return output
def blind_sticky_random(self, turns, min_count, max_count):
if min_count == 42:
return '({} for {})'.format(emoji_dict['super_blind'], turns)
else:
return '({} {} for {})' \
.format(minmax(min_count, max_count), emoji_dict['super_blind'], turns)
def blind_sticky_random(self, turns, min_count, max_count):
if min_count == 42:
return 'Blind all orbs for {:s}'.format(noun_count('turn', turns))
else:
return 'Blind random {:s} orbs for {:s}' \
.format(minmax(min_count, max_count), noun_count('turn', turns))
def blind_sticky_random(self, turns, min_count, max_count):
if min_count == 42:
return '{}턴동안 모든 드롭을 초암흑으로 가림'.format(turns)
else:
return '{}턴동안 무작위 {}개의 드롭을 초암흑으로 가림' \
.format(turns, minmax(min_count, max_count))
def skill_delay(self, min_turns, max_turns):
return 'Delay active skills by {:s}' \
.format(noun_count('turn', minmax(min_turns, max_turns)))
def skill_delay(self, min_turns, max_turns):
return "({}-[{}])".format(emoji_dict['skill_delay'],
minmax(min_turns, max_turns))
def suicide_random_nuke_convert(self, act):
skill_text = self.suicide_convert(act) + '; '
skill_text += 'Deal ' + minmax(act.maximum_multiplier, act.minimum_multiplier, fmt=True) \
+ 'x ' + self.ATTRIBUTES[act.attribute] + ' damage to ' + self.fmt_mass_atk(act.mass_attack)
return skill_text
def skill_delay(self, min_turns, max_turns):
return '아군의 액티브 스킬 대기 턴 {}턴 증가'.format(minmax(min_turns, max_turns))
