def get_item_menu(self, item_id, item_name):
buttons = []
item = self.get_item_object(item_id, item_name=item_name)
table_row = item.table_row
actions = self.get_item_actions(item, item_id)
for action in actions:
buttons.append(
keyboards.DungeonButton(action[0],
self.member,
'item',
action[1],
item_id,
item_name,
named=True))
buttons.append(
keyboards.DungeonButton('Назад',
self.member,
'item',
'menu',
named=True))
keyboard = keyboards.form_keyboard(*buttons)
text = LangTuple(table_row, 'name').translate(self.member.lang) + '\n' \
+ LangTuple(table_row, 'desc').translate(self.member.lang)
self.member.edit_message(text, reply_markup=keyboard)
self.member.menu.update()
def info_string(self, lang=None):
lang = self.lang if lang is None else lang
ability_list = ', '.join([LangTuple('abilities_' + ability.name, 'name').translate(lang)
for ability in self.abilities if 'tech' not in ability.types])
item_list = ', '.join([LangTuple('items_' + item.name, 'button').translate(lang)
for item in self.items])
return LangTuple('utils', 'full_info', format_dict={'actor': self.name,
'hp': self.hp,
'energy': self.energy,
'abilities': ability_list,
'items': item_list})
def member_string(self):
inventory = self.inventory.get_inventory_string(self.lang)
inventory_fill = LangTuple('utils',
'empty') if not inventory else LangTuple(
'utils', 'inventory')
return LangTuple('unit_' + self['unit_name'],
'dungeon_menu',
format_dict=units.units_dict[
self['unit_name']].get_dungeon_format_dict(
self, inventory,
inventory_fill)).translate(self.lang)
def add_armor_string(self):
for key in self.act_armor_dict:
armor_string = LangTuple('fight',
'armor',
format_dict={
'actor': self.name,
'damage_blocked':
self.act_armor_dict[key],
'armor': LangTuple('armor', key)
})
standart_actions.AddString(armor_string, 22, self)
self.act_armor_dict = {}
def get_item_name(self, item, lang):
if isinstance(item, str):
return LangTuple(self.get_item_tuple(item), 'name').translate(lang)
elif isinstance(item, dict):
return LangTuple(self.get_item_tuple(item['name']),
'name').translate(lang)
else:
name = LangTuple(self.get_item_tuple(item[0]['name']),
'name').translate(lang)
if 'improved' in item[0].keys():
if item[0]['improved'] > 0:
name += ' +' + str(item['improved'])
return name
def menu_string(self):
return LangTuple('unit_' + self.unit_name,
'player_menu',
format_dict={
'actor':
self.name,
'hp':
self.hp,
'energy':
self.energy,
'weapon':
LangTuple('weapon_' + self.weapon.name, 'name'),
'statuses':
self.get_status_string()
})
def dies(self):
if not self.alive() and self not in self.fight.dead:
self.add_death_effect()
self.fight.string_tuple.row(
LangTuple('fight', 'death', format_dict={'actor': self.name}))
return True
return False
def update_menu(self):
buttons = self.inventory_buttons()
keyboard = form_keyboard(*buttons)
self.member.edit_message(LangTuple('utils_inventory',
'name').translate(self.member.lang),
reply_markup=keyboard)
self.member.menu.update()
def grab(self, target):
if 'dodge' in target.action or 'back' in target.action:
self.string('skill_8',
format_dict={
'actor': self.name,
'target': target.name
})
else:
self.string('skill_1',
format_dict={
'actor': self.name,
'target': target.name
})
statuses.CustomStatus(target,
21,
70,
self.tighten,
name='branch-grabbed',
additional_buttons_actions=[
('free', self.force_free,
LangTuple('unit_' + self.unit_name,
'button_1'))
])
self.move_forward()
target.rooted.append(self)
self.state = 'grabbed'
def dies(self):
if not self.alive() and self not in self.fight.dead:
if self.death_lang_tuple is None:
self.fight.string_tuple.row(
LangTuple('fight',
'death',
format_dict={'actor': self.name}))
else:
death_tuple = self.get_death_effect_tuple(
self.death_lang_tuple)
if death_tuple is not None:
self.fight.string_tuple.row(death_tuple)
else:
self.fight.string_tuple.row(
LangTuple('fight',
'death',
format_dict={'actor': self.name}))
return True
return False
def distribute_loot(self, loot_container):
loot_receivers = list(self.members)
random.shuffle(loot_receivers)
if not loot_container.empty():
player_containers = loot_container.random_split(
len(loot_receivers))
loot_list = dict(zip(loot_receivers, player_containers))
for member in loot_receivers:
message = LangTuple('dungeon', 'loot').translate(member.lang)
if not loot_list[member].empty():
item_list = loot_list[member].to_string(member.lang)
message += '\n' + LangTuple('dungeon',
'found', format_dict={'name': member.name,
'item': item_list}). \
translate(member.lang) if loot_list[member] else \
'\n' + LangTuple('dungeon', 'full-inv', format_dict={'name': member}). \
translate(member.lang)
self.member_dict[
member.chat_id].inventory += loot_list[member]
bot_methods.send_message(member.chat_id, message)
def form_message(*rgs, sh_m_ui=False, memb=None):
if sh_m_ui:
rgs = [
*rgs,
LangTuple(
'dungeon_short-member',
'name',
format_dict=units.units_dict[
memb['unit_name']].get_dungeon_format_dict(memb))
]
msg = '\n'.join([arg.translate(self.leader.lang) for arg in rgs])
return msg
def get_menu_string(self):
abilities = self.user.get_abilities()
ability_names = [
ability().name_lang_tuple().translate('rus')
for ability in [ability_dict[abl['name']] for abl in abilities]
]
ability_names = ', '.join(ability_names)
return LangTuple('chatmanagement',
'player_menu',
format_dict={
'experience': self.user.experience,
'abilities': ability_names
}).translate('rus')
def menu_string(self):
return LangTuple('unit_' + self.unit_name,
'player_menu',
format_dict={
'actor':
self.name,
'bones':
self.wounds,
'head':
emote_dict['check_em' if self.
bone_dict['head'] else 'cross_em'],
'arm':
emote_dict['check_em' if self.
bone_dict['arms'] else 'cross_em'],
'leg':
emote_dict['check_em' if self.
bone_dict['legs'] else 'cross_em'],
'weapon':
LangTuple('weapon_' + self.weapon.name, 'name'),
'statuses':
self.get_status_string()
})
def show_chat_stats(self, lang):
receipts = self.get_receipts()
message = ''
for key in receipts:
name = standart_actions.get_name(key, 'rus')
if receipts[key] == 'inf':
value = 'Много'
else:
value = str(receipts[key])
message += name + ' - ' + value + '\n'
used_items = engine.ChatContainer(base_dict=self.get_free_armory())
lang_tuple = LangTuple('chatmanagement',
'chat_stats',
format_dict={
'resources':
str(self.resources),
'items':
used_items.to_string(lang,
marked=True,
emoted=True)
})
self.send_message(lang_tuple.translate(lang))
def menu_string(self):
if len(self.weapon.targets()) != 1 or self.weapon.special_types:
return LangTuple('unit_' + self.unit_name,
'player_menu',
format_dict={
'actor':
self.name,
'hp':
self.hp,
'energy':
self.energy,
'weapon':
LangTuple('weapon_' + self.weapon.name,
'name'),
'statuses':
self.get_status_string()
})
else:
menu_string = LangTuple('unit_' + self.unit_name,
'player_menu',
format_dict={
'actor':
self.name,
'hp':
self.hp,
'energy':
self.energy,
'weapon':
LangTuple('weapon_' + self.weapon.name,
'name'),
'statuses':
self.get_status_string()
}).translate(self.controller.lang)
menu_string += '\n'
# menu_string += self.weapon.get_menu_string(short_menu=False, target=self.weapon.targets()[0].name).translate(self.controller.lang)
return menu_string
def get_button_tuples(self, lang):
button_tuples = json.loads(LangTuple(self.table_row, 'buttons').translate(lang))
return button_tuples
def greetings_message(self):
for member in self.dungeon.party.members:
message = LangTuple(self.table_row, 'greeting').translate(member.lang)
bot_methods.send_message(member.chat_id, message)
def get_string(self, string_action, format_dict=None):
return LangTuple('buildings_' + self.name, string_action, format_dict=format_dict)
def get_lang_tuple(self, string, format_dict=None):
return LangTuple(self.table_row, string, format_dict=format_dict)
def get_greet_tuple(self):
return LangTuple(self.table_row, 'greeting')
def victory(self):
self.dungeon.party.send_message(LangTuple('dungeon', 'victory'), image=self.image,
reply_markup_func=self.get_action_keyboard)
def get_lang_tuple(self, string):
return LangTuple(self.table_row, string)