Croc/croccybot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(skins): Implement CustomSkin editor.

Browse Source
This commit is contained in:
Conatum
2023-10-29 03:30:49 +02:00
parent 02068bd6b9
commit d1b9a95bd2
16 changed files with 3585 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

298
src/modules/skins/editor/skinsetting.py
View File

@@ -0,0 +1,298 @@
from typing import Literal, Optional
from enum import Enum
from discord.ui import TextInput
from meta import LionBot
from meta.errors import UserInputError
from babel.translator import LazyStr
from gui.base import Card, FieldDesc, AppSkin
from .. import babel
from ..skinlib import CustomSkin
_p = babel._p
class SettingInputType(Enum):
SkinInput = -1
ModalInput = 0
MenuInput = 1
ButtonInput = 2
class Setting:
"""
An abstract base interface for a custom skin 'setting'.
A skin setting is considered to be some readable and usually writeable
information extractable from a `CustomSkin`.
This will usually consist of the value of one or more properties,
which are themselves associated to fields of GUI Cards.
The methods in this ABC describe the interface for such a setting.
Each method accepts a `CustomSkin`,
and an implementation should describe how to
get, set, parse, format, or display the setting
for that given skin.
This is very similar to how Settings are implemented in the bot,
except here all settings have a shared external source of state, the CustomSkin.
Thus, each setting is simply an instance of an appropriate setting class,
rather than a class itself.
"""
# What type of input method this setting requires for input
input_type: SettingInputType = SettingInputType.ModalInput
def __init__(self, *args, display_name, description, **kwargs):
self.display_name: LazyStr = display_name
self.description: LazyStr = description
def default_value_in(self, skin: CustomSkin) -> Optional[str]:
"""
The default value of this setting in this skin.
This takes into account base skin data and localisation.
May be `None` if the setting does not have a default value.
"""
raise NotImplementedError
def value_in(self, skin: CustomSkin) -> Optional[str]:
"""
The current value of this setting from this skin.
May be None if the setting is not set or does not have a value.
Usually should not take into account defaults.
"""
raise NotImplementedError
def set_in(self, skin: CustomSkin, value: Optional[str]):
"""
Set this setting to the given value in this skin.
"""
raise NotImplementedError
def format_value_in(self, skin: CustomSkin, value: Optional[str]) -> str:
"""
Format the given setting value for display (typically in a setting table).
"""
raise NotImplementedError
async def parse_input(self, skin: CustomSkin, userstr: str) -> Optional[str]:
"""
Parse a user provided string into a value for this setting.
Will raise 'UserInputError' with a readable message if parsing fails.
"""
raise NotImplementedError
def make_input_field(self, skin: CustomSkin) -> TextInput:
"""
Create a TextInput field for this setting, using the current value.
"""
raise NotImplementedError
class PropertySetting(Setting):
"""
A skin setting corresponding to a single property of a single card.
Note that this is still abstract,
as it does not implement any formatting or parsing methods.
This will usually (but may not always) correspond to a single Field of the card skin.
"""
def __init__(self, card: type[Card], property_name: str, **kwargs):
super().__init__(**kwargs)
self.card = card
self.property_name = property_name
@property
def card_id(self):
"""
The `card_id` of the Card class this setting belongs to.
"""
return self.card.card_id
@property
def field(self) -> Optional[FieldDesc]:
"""
The CardSkin field overwrriten by this setting, if it exists.
"""
return self.card.skin._fields.get(self.property_name, None)
def default_value_in(self, skin: CustomSkin) -> Optional[str]:
"""
For a PropertySetting, the default value is determined as follows:
base skin value from:
- card base skin
- custom base skin
- global app base skin
fallback (field) value from the CardSkin
"""
base_skin = skin.get_prop(self.card_id, 'base_skin_id')
base_skin = base_skin or skin.base_skin_name
base_skin = base_skin or skin.cog.current_default
app_skin_args = AppSkin.get(base_skin).for_card(self.card_id)
if self.property_name in app_skin_args:
return app_skin_args[self.property_name]
elif self.field:
return self.field.default
else:
return None
def value_in(self, skin: CustomSkin) -> Optional[str]:
return skin.get_prop(self.card_id, self.property_name)
def set_in(self, skin: CustomSkin, value: Optional[str]):
skin.set_prop(self.card_id, self.property_name, value)
class _ColourInterface(Setting):
"""
Skin setting mixin for parsing and formatting colour typed settings.
"""
def format_value_in(self, skin: CustomSkin, value: Optional[str]) -> str:
if value:
formatted = f"`{value}`"
else:
formatted = skin.bot.translator.t(_p(
'skinsettings|colours|format:not_set',
"Not Set"
))
return formatted
async def parse_input(self, skin: CustomSkin, userstr: str) -> Optional[str]:
stripped = userstr.strip('# ').upper()
if not stripped:
value = None
elif len(stripped) not in (6, 8) or any(c not in '0123456789ABCDEF' for c in stripped):
raise UserInputError(
skin.bot.translator.t(_p(
'skinsettings|colours|parse|error:invalid',
"Could not parse `{given}` as a colour!"
" Please use RGB/RGBA format (e.g. `#ABABABF0`)."
)).format(given=userstr)
)
else:
value = f"#{stripped}"
return value
def make_input_field(self, skin: CustomSkin) -> TextInput:
t = skin.bot.translator.t
value = self.value_in(skin)
default_value = self.default_value_in(skin)
label = t(self.display_name)
default = value
if default_value:
placeholder = f"{default_value} ({t(self.description)})"
else:
placeholder = t(self.description)
return TextInput(
label=label,
placeholder=placeholder,
default=default,
min_length=0,
max_length=9,
required=False,
)
class ColourSetting(_ColourInterface, PropertySetting):
"""
A Property skin setting representing a single colour field.
"""
pass
class SkinSetting(PropertySetting):
"""
A Property setting representing the base skin of a card.
"""
input_type = SettingInputType.SkinInput
def format_value_in(self, skin: CustomSkin, value: Optional[str]) -> str:
if value:
app_skin = AppSkin.get(value)
formatted = f"`{app_skin.display_name}`"
else:
formatted = skin.bot.translator.t(_p(
'skinsettings|base_skin|format:not_set',
"Default"
))
return formatted
def default_value_in(self, skin: CustomSkin) -> Optional[str]:
return skin.base_skin_name
class CompoundSetting(Setting):
"""
A Setting combining several PropertySettings across (potentially) multiple cards.
"""
NOTSHARED = ''
def __init__(self, *settings: PropertySetting, **kwargs):
super().__init__(**kwargs)
self.settings = settings
def default_value_in(self, skin: CustomSkin) -> Optional[str]:
"""
The default value of a CompoundSetting is the shared default of the component settings.
If the components do not share a default value, returns None.
"""
value = None
for setting in self.settings:
setting_value = setting.default_value_in(skin)
if setting_value is None:
value = None
break
if value is None:
value = setting_value
elif value != setting_value:
value = None
break
return value
def value_in(self, skin: CustomSkin) -> Optional[str]:
"""
The value of a compound setting is the shared value of the components.
"""
value = self.NOTSHARED
for setting in self.settings:
setting_value = setting.value_in(skin) or setting.default_value_in(skin)
if value is self.NOTSHARED:
value = setting_value
elif value != setting_value:
value = self.NOTSHARED
break
return value
def set_in(self, skin: CustomSkin, value: Optional[str]):
"""
Set all of the components individually.
"""
for setting in self.settings:
setting.set_in(skin, value)
class ColoursSetting(_ColourInterface, CompoundSetting):
"""
Compound setting representing multiple colours.
"""
def format_value_in(self, skin: CustomSkin, value: Optional[str]) -> str:
if value is self.NOTSHARED:
return "Mixed"
elif value is None:
return "Not Set"
else:
return f"`{value}`"