async def get_image_url(item_info: EntityInfo) -> Optional[str]:
logo_sprite_id = item_info.get('LogoSpriteId')
image_sprite_id = item_info.get('ImageSpriteId')
if entity.entity_property_has_value(logo_sprite_id) and logo_sprite_id != image_sprite_id:
return await sprites.get_download_sprite_link(logo_sprite_id)
elif entity.entity_property_has_value(image_sprite_id):
return await sprites.get_download_sprite_link(image_sprite_id)
else:
return None
def __get_type(item_info: EntityInfo, items_data: EntitiesData, trainings_data: EntitiesData = None, **kwargs) -> Optional[str]:
item_sub_type = item_info.get('ItemSubType')
if entity.entity_property_has_value(item_sub_type) and 'Equipment' not in item_sub_type:
result = item_sub_type.replace('Equipment', '')
else:
item_type = item_info.get('ItemType')
if entity.entity_property_has_value(item_type):
result = item_type
else:
result = None
return result
def __get_embed_color(collection_info: EntityInfo, collections_data: EntitiesData, characters_data: EntitiesData, **kwargs) -> Colour:
color_string = collection_info.get('ColorString')
if entity.entity_property_has_value(color_string):
result = utils.discord.convert_color_string_to_embed_color(color_string)
else:
result = Embed.Empty
return result
async def get_download_sprite_link(sprite_id: str) -> Optional[str]:
if entity.entity_property_has_value(sprite_id):
base_url = await core.get_base_url()
result = f'{base_url}FileService/DownloadSprite?spriteId={sprite_id}'
return result
else:
return None
async def __get_image_url(item_info: EntityInfo, items_data: EntitiesData, trainings_data: EntitiesData = None, **kwargs) -> Optional[str]:
logo_sprite_id = item_info.get('LogoSpriteId')
image_sprite_id = item_info.get('ImageSpriteId')
if entity.entity_property_has_value(logo_sprite_id) and logo_sprite_id != image_sprite_id:
return await sprites.get_download_sprite_link(logo_sprite_id)
else:
return None
async def get_ship_builder_links(
ctx: Context,
user_info: entity.EntityInfo,
as_embed: bool = settings.USE_EMBEDS) -> Union[List[Embed], List[str]]:
user_info, user_ship_info = await get_inspect_ship_for_user(
user_info[user.USER_KEY_NAME])
ship_design_id = user_ship_info[SHIP_DESIGN_KEY_NAME]
ships_designs_data = await ships_designs_retriever.get_data_dict3()
ship_design_info = ships_designs_data[ship_design_id]
rooms = '-'.join([
','.join((ship_room_info['Column'], ship_room_info['Row'],
ship_room_info[room.ROOM_DESIGN_KEY_NAME]))
for ship_room_info in user_ship_info['Rooms'].values()
])
query_params = f'ship={ship_design_id}&rooms={rooms}'
pixel_prestige_link = f'{SHIP_BUILDER_PIXEL_PRESTIGE_BASE_PATH}{query_params}'
pixyship_link = f'{SHIP_BUILDER_PIXYSHIP_BASE_PATH}{query_params}'
ship_builder_links = [('Pixel Prestige builder', pixel_prestige_link),
('Pixyship builder', pixyship_link)]
fields = []
fleet_name = user_info.get(fleet.FLEET_DESCRIPTION_PROPERTY_NAME)
if entity.entity_property_has_value(fleet_name):
fields.append(('Fleet', escape_markdown(fleet_name), False))
fields += [
('Trophies', user_info['Trophy'], None),
('Ship',
f'{ship_design_info["ShipDesignName"]} (level {ship_design_info["ShipLevel"]})',
None),
]
post_title = user_info[user.USER_DESCRIPTION_PROPERTY_NAME]
if as_embed:
miniship_sprite_url = await sprites.get_download_sprite_link(
ship_design_info.get('MiniShipSpriteId'))
user_pin_sprite_url = await sprites.get_download_sprite_link(
user_info.get('IconSpriteId'))
colour = utils.discord.get_bot_member_colour(ctx.bot, ctx.guild)
result = utils.discord.create_basic_embeds_from_fields(
post_title,
fields=fields,
colour=colour,
thumbnail_url=miniship_sprite_url,
icon_url=user_pin_sprite_url)
for title, link in ship_builder_links:
result.append(
utils.discord.create_embed(post_title,
description=f'[{title}]({link})',
colour=colour,
thumbnail_url=miniship_sprite_url,
icon_url=user_pin_sprite_url))
else:
for title, link in ship_builder_links:
fields.append((title, f'<{link}>', None))
result = [
f'{key}{entity.DEFAULT_DETAIL_PROPERTY_LONG_SEPARATOR}{value}'
for key, value, _ in fields
]
result.insert(
0, f'**Ship builder links for {escape_markdown(post_title)}**')
return result
async def get_event_details(
ctx: Context,
situation_id: str = None,
all_events: bool = False,
latest_only: bool = False,
as_embed: bool = settings.USE_EMBEDS) -> Union[List[Embed], List[str]]:
has_situation_id = entity.entity_property_has_value(situation_id)
if has_situation_id and all_events or has_situation_id and latest_only or all_events and latest_only:
raise ValueError(
f'Only one of these parameters may be True: situation_id, all_events, latest_only'
)
utc_now = utils.get_utc_now()
situations_data = await situations_designs_retriever.get_data_dict3()
situation_infos = sorted(situations_data.values(),
key=lambda x:
(utils.parse.pss_datetime(x['EndDate']),
int(x[SITUATION_DESIGN_KEY_NAME])),
reverse=True)
if situation_id:
situation_infos = [situations_data[situation_id]]
elif all_events:
situation_infos.reverse()
elif latest_only:
situation_infos = [situation_infos[0]]
else:
situation_infos = __get_current_situations_infos(
situations_data.values(), utc_now)
if not situation_infos:
if all_events:
raise NotFound(f'There\'s no event data.')
else:
raise NotFound(f'There\'s no event running currently.')
else:
chars_data = await crew.characters_designs_retriever.get_data_dict3()
collections_data = await crew.collections_designs_retriever.get_data_dict3(
)
items_data = await item.items_designs_retriever.get_data_dict3()
missions_data = await mission.missions_designs_retriever.get_data_dict3(
)
rooms_data = await room.rooms_designs_retriever.get_data_dict3()
situations_details_collection = __create_situations_details_collection_from_infos(
situation_infos,
situations_data,
chars_data,
collections_data,
items_data,
missions_data,
rooms_data,
utc_now=utc_now)
if as_embed:
return (await situations_details_collection.
get_entities_details_as_embed(ctx))
else:
return (
await
situations_details_collection.get_entities_details_as_text())
async def __get_thumbnail_url(training_info: EntityInfo, trainings_data: EntitiesData, items_data: EntitiesData, researches_data: EntitiesData, **kwargs) -> Optional[str]:
training_sprite_id = training_info.get('TrainingSpriteId')
sprite_id = None
if entity.entity_property_has_value(training_sprite_id) and training_sprite_id != '454':
sprite_id = training_sprite_id
else:
training_id = training_info.get(TRAINING_DESIGN_KEY_NAME)
item_details = item.get_item_details_by_training_id(training_id, items_data, trainings_data)
if item_details:
item_sprite_id = item_details[0].entity_info.get('ImageSpriteId')
if entity.entity_property_has_value(item_sprite_id):
sprite_id = item_sprite_id
if sprite_id:
result = await sprites.get_download_sprite_link(sprite_id)
else:
result = None
return result
def __filter_destroyed_modules_from_item_infos(
items_infos: List[EntityInfo]) -> List[EntityInfo]:
result = [
item_info for item_info in items_infos
if item_info.get('ItemSubType') != 'Module'
or entity.entity_property_has_value(item_info.get('ModuleArgument'))
]
return result
def __get_key_for_base_items_sort(item_info: EntityInfo, items_data: EntitiesData) -> str:
result = item_info.get(ITEM_DESIGN_DESCRIPTION_PROPERTY_NAME)
item_sub_type = item_info.get('ItemSubType')
if entity.entity_property_has_value(item_sub_type) and item_sub_type in lookups.ITEM_SUB_TYPES_TO_GET_PARENTS_FOR:
parents = __get_parents(item_info, items_data)
if parents:
result = parents[0].get(ITEM_DESIGN_DESCRIPTION_PROPERTY_NAME)
result += ''.join([item_info.get(ITEM_DESIGN_KEY_NAME).zfill(4) for item_info in parents])
return result
async def __get_training_mini_details(item_info: EntityInfo, items_data: EntitiesData, trainings_data: EntitiesData, **kwargs) -> Optional[str]:
for_embed = kwargs.get('for_embed', False)
training_design_id = item_info.get(training.TRAINING_DESIGN_KEY_NAME)
if entity.entity_property_has_value(training_design_id):
training_design_details: entity.EntityDetails = await training.get_training_details_from_id(training_design_id, trainings_data, items_data)
result = await training_design_details.get_details_as_text(entity.EntityDetailsType.MINI, for_embed=for_embed)
return ''.join(result)
else:
return None
def __get_parents(item_info: EntityInfo, items_data: EntitiesData) -> List[EntityInfo]:
item_design_id = item_info.get(ITEM_DESIGN_KEY_NAME)
root_item_design_id = item_info.get('RootItemDesignId')
result = []
if entity.entity_property_has_value(root_item_design_id) and item_design_id != root_item_design_id:
parent_info = items_data.get(root_item_design_id)
if parent_info:
result = __get_parents(parent_info, items_data)
result.append(parent_info)
return result
def __get_situation_trigger(situation_info: EntityInfo,
situations_data: EntitiesData,
chars_data: EntitiesData,
collections_data: EntitiesData,
items_data: EntitiesData,
missions_data: EntitiesData,
rooms_data: EntitiesData,
**kwargs) -> Optional[str]:
trigger_type = situation_info.get('TriggerType')
if entity.entity_property_has_value(trigger_type):
return SITUATION_TRIGGER_TYPE_LOOKUP.get(trigger_type, trigger_type)
return None
def __get_situation_chance(situation_info: EntityInfo,
situations_data: EntitiesData,
chars_data: EntitiesData,
collections_data: EntitiesData,
items_data: EntitiesData,
missions_data: EntitiesData,
rooms_data: EntitiesData,
**kwargs) -> Optional[str]:
chance = situation_info.get('Chance')
if entity.entity_property_has_value(chance):
result = f'{chance} %'
else:
result = None
return result
async def __get_shop_msg_from_info_as_text(
daily_info: EntityInfo, chars_data: EntitiesData,
collections_data: EntitiesData, items_data: EntitiesData,
rooms_data: EntitiesData,
trainings_data: EntitiesData) -> Tuple[List[str], str]:
result = [f'{emojis.pss_shop} **Shop**']
shop_type = daily_info['LimitedCatalogType']
currency_type = daily_info['LimitedCatalogCurrencyType']
currency_emoji = lookups.CURRENCY_EMOJI_LOOKUP.get(currency_type.lower(),
currency_type)
price = daily_info['LimitedCatalogCurrencyAmount']
can_own_max = daily_info['LimitedCatalogMaxTotal']
entity_id = daily_info['LimitedCatalogArgument']
entity_details_txt = []
if shop_type == 'Character':
char_details = crew.get_char_details_by_id(entity_id, chars_data,
collections_data)
entity_details_txt = await char_details.get_details_as_text(
entity.EntityDetailsType.SHORT)
sprite_id = char_details.entity_info.get('ProfileSpriteId')
elif shop_type == 'Item':
item_details = item.get_item_details_by_id(entity_id, items_data,
trainings_data)
entity_details_txt = await item_details.get_details_as_text(
entity.EntityDetailsType.SHORT)
logo_sprite_id = item_details.entity_info.get('LogoSpriteId')
image_sprite_id = item_details.entity_info.get('ImageSpriteId')
sprite_id = logo_sprite_id if logo_sprite_id != image_sprite_id else None
elif shop_type == 'Room':
room_details = room.get_room_details_by_id(entity_id, rooms_data, None,
None, None)
entity_details_txt = await room_details.get_details_as_text(
entity.EntityDetailsType.SHORT)
sprite_id = room_details.entity_info.get('ImageSpriteId')
else:
result.append('-')
return result, None
if entity_details_txt:
result.extend(entity_details_txt)
sprite_id = sprite_id if entity.entity_property_has_value(
sprite_id) else None
result.append(f'Cost: {price} {currency_emoji}')
result.append(f'Can own (max): {can_own_max}')
return result, sprite_id
async def __get_sale_msg_from_info_as_text(
daily_info: EntityInfo, chars_data: EntitiesData,
collections_data: EntitiesData, items_data: EntitiesData,
rooms_data: EntitiesData, trainings_data: EntitiesData) -> List[str]:
# 'SaleItemMask': use lookups.SALE_ITEM_MASK_LOOKUP to print which item to buy
result = [f'{emojis.pss_sale} **Sale**']
sale_type = daily_info['SaleType']
if not entity.entity_property_has_value(sale_type):
return []
sale_items = utils.convert.iap_options_mask(int(
daily_info['SaleItemMask']))
sale_quantity = daily_info['SaleQuantity']
result.append(f'Buy a {sale_items} _of Starbux_ and get:')
sale_argument = daily_info['SaleArgument']
if sale_type == 'Character':
char_details = crew.get_char_details_by_id(sale_argument, chars_data,
collections_data)
entity_details = ''.join(await char_details.get_details_as_text(
entity.EntityDetailsType.SHORT))
elif sale_type == 'Item':
item_details = item.get_item_details_by_id(sale_argument, items_data,
trainings_data)
entity_details = ''.join(await item_details.get_details_as_text(
entity.EntityDetailsType.SHORT))
elif sale_type == 'Room':
room_details = room.get_room_details_by_id(sale_argument, rooms_data,
None, None, None)
entity_details = ''.join(await room_details.get_details_as_text(
entity.EntityDetailsType.SHORT))
elif sale_type == 'Bonus':
entity_details = f'{sale_argument} % bonus starbux'
else: # Print debugging info
sale_title = daily_info['SaleTitle']
debug_details = []
debug_details.append(f'Sale Type: {sale_type}')
debug_details.append(f'Sale Argument: {sale_argument}')
debug_details.append(f'Sale Title: {sale_title}')
entity_details = '\n'.join(debug_details)
result.append(f'{sale_quantity} x {entity_details}')
return result
async def __get_current_events_details_as_text(
situations_designs_data: EntitiesData,
chars_designs_data: EntitiesData,
collections_designs_data: EntitiesData,
items_designs_data: EntitiesData, missions_designs_data: EntitiesData,
rooms_designs_data: EntitiesData,
utc_now: datetime) -> Optional[Tuple[List[str], str]]:
events_details = await situation.get_current_events_details(
situations_designs_data, chars_designs_data, collections_designs_data,
items_designs_data, missions_designs_data, rooms_designs_data, utc_now)
if events_details:
result = []
sprite_id = None
for event_details in events_details:
result.append(''.join(await event_details.get_details_as_text(
entity.EntityDetailsType.SHORT)))
icon_sprite_id = event_details.entity_info['IconSpriteId']
if not sprite_id and entity.entity_property_has_value(
icon_sprite_id):
sprite_id = icon_sprite_id
return result, sprite_id
else:
return None, None
async def __get_event_reward(
change_type: str,
change_argument: str,
chars_data: EntitiesData,
collections_data: EntitiesData,
items_data: EntitiesData,
for_embed: Optional[bool] = False) -> Optional[str]:
if for_embed is None:
for_embed = False
result = None
reward_amount = None
reward_details = None
if entity.entity_property_has_value(change_argument):
entity_type, entity_id, reward_amount, _ = utils.parse.entity_string(
change_argument, default_amount=None)
if entity_type == 'character':
reward_details = crew.get_char_details_by_id(
entity_id, chars_data, collections_data)
elif entity_type == 'item':
reward_details = item.get_item_details_by_id(
entity_id, items_data, None)
else:
reward_amount = int(change_argument)
if reward_details:
details_text = "".join(await reward_details.get_details_as_text(
entity.EntityDetailsType.MINI, for_embed=for_embed))
if reward_amount:
result = f'{reward_amount}x {details_text}'
else:
result = details_text
elif change_type == 'AddLeagueBonusGas':
result = f'{reward_amount+100} % league bonus for {emojis.pss_gas_big}'
elif change_type == 'AddEXP':
result = f'{reward_amount} % exp from battles'
else:
result = change_argument
return result
def __get_value(*args, **kwargs) -> Optional[str]:
entity_property = kwargs.get('entity_property')
if entity.entity_property_has_value(entity_property):
return entity_property
else:
return None
async def make_ship_layout_sprite(
file_name_prefix: str, user_ship_info: entity.EntityInfo,
ship_design_info: entity.EntityInfo,
rooms_designs_data: entity.EntitiesData,
rooms_designs_sprites_ids: Dict[str, str]) -> str:
user_id = user_ship_info['UserId']
brightness_value = float(user_ship_info.get('BrightnessValue', '0'))
hue_value = float(user_ship_info.get('HueValue', '0'))
saturation_value = float(user_ship_info.get('SaturationValue', '0'))
interior_sprite_id = ship_design_info['InteriorSpriteId']
interior_sprite = await sprites.load_sprite(interior_sprite_id)
interior_sprite = sprites.enhance_sprite(interior_sprite,
brightness=brightness_value,
hue=hue_value,
saturation=saturation_value)
interior_grid_sprite = await sprites.load_sprite_from_disk(
interior_sprite_id, suffix='grids')
if not interior_grid_sprite:
interior_grid_sprite = make_interior_grid_sprite(
ship_design_info, interior_sprite.width, interior_sprite.height)
interior_sprite.paste(interior_grid_sprite, (0, 0), interior_grid_sprite)
room_frame_sprite_id = ship_design_info.get('RoomFrameSpriteId')
door_frame_left_sprite_id = ship_design_info.get('DoorFrameLeftSpriteId')
door_frame_right_sprite_id = ship_design_info.get('DoorFrameRightSpriteId')
rooms_sprites_cache = {}
rooms_decorations_sprites_cache = {}
for ship_room_info in user_ship_info['Rooms'].values():
room_design_id = ship_room_info[room.ROOM_DESIGN_KEY_NAME]
room_under_construction = 1 if ship_room_info.get(
'RoomStatus') == 'Upgrading' or entity.entity_property_has_value(
ship_room_info.get('ConstructionStartDate')) else 0
room_sprite = rooms_sprites_cache.get(room_design_id,
{}).get(room_under_construction)
if not room_sprite:
room_design_info = rooms_designs_data[room_design_id]
room_size = (int(room_design_info['Columns']),
int(room_design_info['Rows']))
if room_size == (1, 1):
room_decoration_sprite = None
else:
room_decoration_sprite = rooms_decorations_sprites_cache.get(
room_frame_sprite_id, {}).get(door_frame_left_sprite_id,
{}).get(room_size)
if not room_decoration_sprite:
room_decoration_sprite = await room.get_room_decoration_sprite(
room_frame_sprite_id, door_frame_left_sprite_id,
door_frame_right_sprite_id, room_size[0], room_size[1])
rooms_decorations_sprites_cache.setdefault(
room_frame_sprite_id, {}).setdefault(
door_frame_left_sprite_id, {}).setdefault(
door_frame_right_sprite_id,
{})[room_size] = room_decoration_sprite
room_sprite_id = room.get_room_sprite_id(
room_design_info, room_under_construction,
room_decoration_sprite is not None, rooms_designs_sprites_ids)
room_sprite = await room.create_room_sprite(
room_sprite_id, room_decoration_sprite, room_design_info,
brightness_value, hue_value, saturation_value)
rooms_sprites_cache.setdefault(
room_design_id, {})[room_under_construction] = room_sprite
interior_sprite.paste(
room_sprite, (int(ship_room_info['Column']) * sprites.TILE_SIZE,
int(ship_room_info['Row']) * sprites.TILE_SIZE))
file_path = sprites.save_sprite(interior_sprite,
f'{file_name_prefix}_{user_id}_layout')
return file_path
def __get_ability(character_info: EntityInfo, characters_data: EntitiesData, collections_data: EntitiesData, level: int, **kwargs) -> Optional[str]:
if entity.entity_property_has_value(character_info['SpecialAbilityType']):
result = lookups.SPECIAL_ABILITIES_LOOKUP.get(character_info['SpecialAbilityType'], character_info['SpecialAbilityType'])
else:
result = None
return result
def get_ingredients_dict(ingredients: str) -> Dict[str, str]:
result = {}
if entity.entity_property_has_value(ingredients):
result = dict(
[ingredient.split('x') for ingredient in ingredients.split('|')])
return result
