bacommon.bs

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""BombSquad specific bits."""
  4
  5from __future__ import annotations
  6
  7import datetime
  8from enum import Enum
  9from dataclasses import dataclass, field
 10from typing import Annotated, override, assert_never
 11
 12from efro.util import pairs_to_flat
 13from efro.dataclassio import ioprepped, IOAttrs, IOMultiType
 14from efro.message import Message, Response
 15
 16# Token counts for our various packs.
 17TOKENS1_COUNT = 50
 18TOKENS2_COUNT = 500
 19TOKENS3_COUNT = 1200
 20TOKENS4_COUNT = 2600
 21
 22
 23@ioprepped
 24@dataclass
 25class PrivatePartyMessage(Message):
 26    """Message asking about info we need for private-party UI."""
 27
 28    need_datacode: Annotated[bool, IOAttrs('d')]
 29
 30    @override
 31    @classmethod
 32    def get_response_types(cls) -> list[type[Response] | None]:
 33        return [PrivatePartyResponse]
 34
 35
 36@ioprepped
 37@dataclass
 38class PrivatePartyResponse(Response):
 39    """Here's that private party UI info you asked for, boss."""
 40
 41    success: Annotated[bool, IOAttrs('s')]
 42    tokens: Annotated[int, IOAttrs('t')]
 43    gold_pass: Annotated[bool, IOAttrs('g')]
 44    datacode: Annotated[str | None, IOAttrs('d')]
 45
 46
 47class ClassicChestAppearance(Enum):
 48    """Appearances bombsquad classic chests can have."""
 49
 50    UNKNOWN = 'u'
 51    DEFAULT = 'd'
 52    L1 = 'l1'
 53    L2 = 'l2'
 54    L3 = 'l3'
 55    L4 = 'l4'
 56    L5 = 'l5'
 57    L6 = 'l6'
 58
 59    @property
 60    def pretty_name(self) -> str:
 61        """Pretty name for the chest in English."""
 62        # pylint: disable=too-many-return-statements
 63        cls = type(self)
 64
 65        if self is cls.UNKNOWN:
 66            return 'Unknown Chest'
 67        if self is cls.DEFAULT:
 68            return 'Chest'
 69        if self is cls.L1:
 70            return 'L1 Chest'
 71        if self is cls.L2:
 72            return 'L2 Chest'
 73        if self is cls.L3:
 74            return 'L3 Chest'
 75        if self is cls.L4:
 76            return 'L4 Chest'
 77        if self is cls.L5:
 78            return 'L5 Chest'
 79        if self is cls.L6:
 80            return 'L6 Chest'
 81
 82        assert_never(self)
 83
 84
 85@ioprepped
 86@dataclass
 87class ClassicAccountLiveData:
 88    """Live account data fed to the client in the bs classic app mode."""
 89
 90    @dataclass
 91    class Chest:
 92        """A lovely chest."""
 93
 94        appearance: Annotated[
 95            ClassicChestAppearance,
 96            IOAttrs('a', enum_fallback=ClassicChestAppearance.UNKNOWN),
 97        ]
 98        unlock_time: Annotated[datetime.datetime, IOAttrs('t')]
 99        ad_allow_time: Annotated[datetime.datetime | None, IOAttrs('at')]
100
101    class LeagueType(Enum):
102        """Type of league we are in."""
103
104        BRONZE = 'b'
105        SILVER = 's'
106        GOLD = 'g'
107        DIAMOND = 'd'
108
109    tickets: Annotated[int, IOAttrs('ti')]
110
111    tokens: Annotated[int, IOAttrs('to')]
112    gold_pass: Annotated[bool, IOAttrs('g')]
113    remove_ads: Annotated[bool, IOAttrs('r')]
114
115    achievements: Annotated[int, IOAttrs('a')]
116    achievements_total: Annotated[int, IOAttrs('at')]
117
118    league_type: Annotated[LeagueType | None, IOAttrs('lt')]
119    league_num: Annotated[int | None, IOAttrs('ln')]
120    league_rank: Annotated[int | None, IOAttrs('lr')]
121
122    level: Annotated[int, IOAttrs('lv')]
123    xp: Annotated[int, IOAttrs('xp')]
124    xpmax: Annotated[int, IOAttrs('xpm')]
125
126    inbox_count: Annotated[int, IOAttrs('ibc')]
127    inbox_count_is_max: Annotated[bool, IOAttrs('ibcm')]
128
129    chests: Annotated[dict[str, Chest], IOAttrs('c')]
130
131
132class DisplayItemTypeID(Enum):
133    """Type ID for each of our subclasses."""
134
135    UNKNOWN = 'u'
136    TICKETS = 't'
137    TOKENS = 'k'
138    TEST = 's'
139    CHEST = 'c'
140
141
142class DisplayItem(IOMultiType[DisplayItemTypeID]):
143    """Some amount of something that can be shown or described.
144
145    Used to depict chest contents or other rewards or prices.
146    """
147
148    @override
149    @classmethod
150    def get_type_id(cls) -> DisplayItemTypeID:
151        # Require child classes to supply this themselves. If we did a
152        # full type registry/lookup here it would require us to import
153        # everything and would prevent lazy loading.
154        raise NotImplementedError()
155
156    @override
157    @classmethod
158    def get_type(cls, type_id: DisplayItemTypeID) -> type[DisplayItem]:
159        """Return the subclass for each of our type-ids."""
160        # pylint: disable=cyclic-import
161
162        t = DisplayItemTypeID
163        if type_id is t.UNKNOWN:
164            return UnknownDisplayItem
165        if type_id is t.TICKETS:
166            return TicketsDisplayItem
167        if type_id is t.TOKENS:
168            return TokensDisplayItem
169        if type_id is t.TEST:
170            return TestDisplayItem
171        if type_id is t.CHEST:
172            return ChestDisplayItem
173
174        # Important to make sure we provide all types.
175        assert_never(type_id)
176
177    def get_description(self) -> tuple[str, list[tuple[str, str]]]:
178        """Return a string description and subs for the item.
179
180        These decriptions are baked into the DisplayItemWrapper and
181        should be accessed from there when available. This allows
182        clients to give descriptions even for newer display items they
183        don't recognize.
184        """
185        raise NotImplementedError()
186
187    # Implement fallbacks so client can digest item lists even if they
188    # contain unrecognized stuff. DisplayItemWrapper contains basic
189    # baked down info that they can still use in such cases.
190    @override
191    @classmethod
192    def get_unknown_type_fallback(cls) -> DisplayItem:
193        return UnknownDisplayItem()
194
195
196@ioprepped
197@dataclass
198class UnknownDisplayItem(DisplayItem):
199    """Something we don't know how to display."""
200
201    @override
202    @classmethod
203    def get_type_id(cls) -> DisplayItemTypeID:
204        return DisplayItemTypeID.UNKNOWN
205
206    @override
207    def get_description(self) -> tuple[str, list[tuple[str, str]]]:
208        import logging
209
210        # Make noise but don't break.
211        logging.exception(
212            'UnknownDisplayItem.get_description() should never be called.'
213            ' Always access descriptions on the DisplayItemWrapper.'
214        )
215        return 'Unknown', []
216
217
218@ioprepped
219@dataclass
220class TicketsDisplayItem(DisplayItem):
221    """Some amount of tickets."""
222
223    count: Annotated[int, IOAttrs('c')]
224
225    @override
226    @classmethod
227    def get_type_id(cls) -> DisplayItemTypeID:
228        return DisplayItemTypeID.TICKETS
229
230    @override
231    def get_description(self) -> tuple[str, list[tuple[str, str]]]:
232        return '${C} Tickets', [('${C}', str(self.count))]
233
234
235@ioprepped
236@dataclass
237class TokensDisplayItem(DisplayItem):
238    """Some amount of tokens."""
239
240    count: Annotated[int, IOAttrs('c')]
241
242    @override
243    @classmethod
244    def get_type_id(cls) -> DisplayItemTypeID:
245        return DisplayItemTypeID.TOKENS
246
247    @override
248    def get_description(self) -> tuple[str, list[tuple[str, str]]]:
249        return '${C} Tokens', [('${C}', str(self.count))]
250
251
252@ioprepped
253@dataclass
254class TestDisplayItem(DisplayItem):
255    """Fills usable space for a display-item - good for calibration."""
256
257    @override
258    @classmethod
259    def get_type_id(cls) -> DisplayItemTypeID:
260        return DisplayItemTypeID.TEST
261
262    @override
263    def get_description(self) -> tuple[str, list[tuple[str, str]]]:
264        return 'Test Display Item Here', []
265
266
267@ioprepped
268@dataclass
269class ChestDisplayItem(DisplayItem):
270    """Display a chest."""
271
272    appearance: Annotated[ClassicChestAppearance, IOAttrs('a')]
273
274    @override
275    @classmethod
276    def get_type_id(cls) -> DisplayItemTypeID:
277        return DisplayItemTypeID.CHEST
278
279    @override
280    def get_description(self) -> tuple[str, list[tuple[str, str]]]:
281        return self.appearance.pretty_name, []
282
283
284@ioprepped
285@dataclass
286class DisplayItemWrapper:
287    """Wraps a DisplayItem and common info."""
288
289    item: Annotated[DisplayItem, IOAttrs('i')]
290    description: Annotated[str, IOAttrs('d')]
291    description_subs: Annotated[list[str] | None, IOAttrs('s')]
292
293    @classmethod
294    def for_display_item(cls, item: DisplayItem) -> DisplayItemWrapper:
295        """Convenience method to wrap a DisplayItem."""
296        desc, subs = item.get_description()
297        return DisplayItemWrapper(item, desc, pairs_to_flat(subs))
298
299
300@ioprepped
301@dataclass
302class ChestInfoMessage(Message):
303    """Request info about a chest."""
304
305    chest_id: Annotated[str, IOAttrs('i')]
306
307    @override
308    @classmethod
309    def get_response_types(cls) -> list[type[Response] | None]:
310        return [ChestInfoResponse]
311
312
313@ioprepped
314@dataclass
315class ChestInfoResponse(Response):
316    """Here's that chest info you asked for, boss."""
317
318    @dataclass
319    class Chest:
320        """A lovely chest."""
321
322        @dataclass
323        class PrizeSet:
324            """A possible set of prizes for this chest."""
325
326            weight: Annotated[float, IOAttrs('w')]
327            contents: Annotated[list[DisplayItemWrapper], IOAttrs('c')]
328
329        appearance: Annotated[
330            ClassicChestAppearance,
331            IOAttrs('a', enum_fallback=ClassicChestAppearance.UNKNOWN),
332        ]
333
334        # How much it costs to unlock *now*.
335        unlock_tokens: Annotated[int, IOAttrs('tk')]
336
337        # When it unlocks on its own.
338        unlock_time: Annotated[datetime.datetime, IOAttrs('t')]
339
340        # Possible prizes we contain.
341        prizesets: Annotated[list[PrizeSet], IOAttrs('p')]
342
343        # Are ads allowed now?
344        ad_allow: Annotated[bool, IOAttrs('aa')]
345
346    chest: Annotated[Chest | None, IOAttrs('c')]
347    user_tokens: Annotated[int | None, IOAttrs('t')]
348
349
350class ClientUITypeID(Enum):
351    """Type ID for each of our subclasses."""
352
353    UNKNOWN = 'u'
354    BASIC = 'b'
355
356
357class ClientUI(IOMultiType[ClientUITypeID]):
358    """Defines some user interface on the client."""
359
360    @override
361    @classmethod
362    def get_type_id(cls) -> ClientUITypeID:
363        # Require child classes to supply this themselves. If we did a
364        # full type registry/lookup here it would require us to import
365        # everything and would prevent lazy loading.
366        raise NotImplementedError()
367
368    @override
369    @classmethod
370    def get_type(cls, type_id: ClientUITypeID) -> type[ClientUI]:
371        """Return the subclass for each of our type-ids."""
372        # pylint: disable=cyclic-import
373        out: type[ClientUI]
374
375        t = ClientUITypeID
376        if type_id is t.UNKNOWN:
377            out = UnknownClientUI
378        elif type_id is t.BASIC:
379            out = BasicClientUI
380        else:
381            # Important to make sure we provide all types.
382            assert_never(type_id)
383        return out
384
385    @override
386    @classmethod
387    def get_unknown_type_fallback(cls) -> ClientUI:
388        # If we encounter some future message type we don't know
389        # anything about, drop in a placeholder.
390        return UnknownClientUI()
391
392
393@ioprepped
394@dataclass
395class UnknownClientUI(ClientUI):
396    """Fallback type for unrecognized entries."""
397
398    @override
399    @classmethod
400    def get_type_id(cls) -> ClientUITypeID:
401        return ClientUITypeID.UNKNOWN
402
403
404class BasicClientUIComponentTypeID(Enum):
405    """Type ID for each of our subclasses."""
406
407    UNKNOWN = 'u'
408    TEXT = 't'
409    LINK = 'l'
410    BS_CLASSIC_TOURNEY_RESULT = 'ct'
411    DISPLAY_ITEMS = 'di'
412    EXPIRE_TIME = 'd'
413
414
415class BasicClientUIComponent(IOMultiType[BasicClientUIComponentTypeID]):
416    """Top level class for our multitype."""
417
418    @override
419    @classmethod
420    def get_type_id(cls) -> BasicClientUIComponentTypeID:
421        # Require child classes to supply this themselves. If we did a
422        # full type registry/lookup here it would require us to import
423        # everything and would prevent lazy loading.
424        raise NotImplementedError()
425
426    @override
427    @classmethod
428    def get_type(
429        cls, type_id: BasicClientUIComponentTypeID
430    ) -> type[BasicClientUIComponent]:
431        """Return the subclass for each of our type-ids."""
432        # pylint: disable=cyclic-import
433
434        t = BasicClientUIComponentTypeID
435        if type_id is t.UNKNOWN:
436            return BasicClientUIComponentUnknown
437        if type_id is t.TEXT:
438            return BasicClientUIComponentText
439        if type_id is t.LINK:
440            return BasicClientUIComponentLink
441        if type_id is t.BS_CLASSIC_TOURNEY_RESULT:
442            return BasicClientUIBsClassicTourneyResult
443        if type_id is t.DISPLAY_ITEMS:
444            return BasicClientUIDisplayItems
445        if type_id is t.EXPIRE_TIME:
446            return BasicClientUIExpireTime
447
448        # Important to make sure we provide all types.
449        assert_never(type_id)
450
451    @override
452    @classmethod
453    def get_unknown_type_fallback(cls) -> BasicClientUIComponent:
454        # If we encounter some future message type we don't know
455        # anything about, drop in a placeholder.
456        return BasicClientUIComponentUnknown()
457
458
459@ioprepped
460@dataclass
461class BasicClientUIComponentUnknown(BasicClientUIComponent):
462    """An unknown basic client component type.
463
464    In practice these should never show up since the master-server
465    generates these on the fly for the client and so should not send
466    clients one they can't digest.
467    """
468
469    @override
470    @classmethod
471    def get_type_id(cls) -> BasicClientUIComponentTypeID:
472        return BasicClientUIComponentTypeID.UNKNOWN
473
474
475@ioprepped
476@dataclass
477class BasicClientUIComponentText(BasicClientUIComponent):
478    """Show some text in the inbox message."""
479
480    text: Annotated[str, IOAttrs('t')]
481    subs: Annotated[list[str], IOAttrs('s', store_default=False)] = field(
482        default_factory=list
483    )
484    scale: Annotated[float, IOAttrs('sc', store_default=False)] = 1.0
485    color: Annotated[
486        tuple[float, float, float, float], IOAttrs('c', store_default=False)
487    ] = (1.0, 1.0, 1.0, 1.0)
488    spacing_top: Annotated[float, IOAttrs('st', store_default=False)] = 0.0
489    spacing_bottom: Annotated[float, IOAttrs('sb', store_default=False)] = 0.0
490
491    @override
492    @classmethod
493    def get_type_id(cls) -> BasicClientUIComponentTypeID:
494        return BasicClientUIComponentTypeID.TEXT
495
496
497@ioprepped
498@dataclass
499class BasicClientUIComponentLink(BasicClientUIComponent):
500    """Show a link in the inbox message."""
501
502    url: Annotated[str, IOAttrs('u')]
503    label: Annotated[str, IOAttrs('l')]
504    subs: Annotated[list[str], IOAttrs('s', store_default=False)] = field(
505        default_factory=list
506    )
507    spacing_top: Annotated[float, IOAttrs('st', store_default=False)] = 0.0
508    spacing_bottom: Annotated[float, IOAttrs('sb', store_default=False)] = 0.0
509
510    @override
511    @classmethod
512    def get_type_id(cls) -> BasicClientUIComponentTypeID:
513        return BasicClientUIComponentTypeID.LINK
514
515
516@ioprepped
517@dataclass
518class BasicClientUIBsClassicTourneyResult(BasicClientUIComponent):
519    """Show info about a classic tourney."""
520
521    tournament_id: Annotated[str, IOAttrs('t')]
522    game: Annotated[str, IOAttrs('g')]
523    players: Annotated[int, IOAttrs('p')]
524    rank: Annotated[int, IOAttrs('r')]
525    trophy: Annotated[str | None, IOAttrs('tr')]
526    prizes: Annotated[list[DisplayItemWrapper], IOAttrs('pr')]
527
528    @override
529    @classmethod
530    def get_type_id(cls) -> BasicClientUIComponentTypeID:
531        return BasicClientUIComponentTypeID.BS_CLASSIC_TOURNEY_RESULT
532
533
534@ioprepped
535@dataclass
536class BasicClientUIDisplayItems(BasicClientUIComponent):
537    """Show some display-items."""
538
539    items: Annotated[list[DisplayItemWrapper], IOAttrs('d')]
540    width: Annotated[float, IOAttrs('w')] = 100.0
541    spacing_top: Annotated[float, IOAttrs('st', store_default=False)] = 0.0
542    spacing_bottom: Annotated[float, IOAttrs('sb', store_default=False)] = 0.0
543
544    @override
545    @classmethod
546    def get_type_id(cls) -> BasicClientUIComponentTypeID:
547        return BasicClientUIComponentTypeID.DISPLAY_ITEMS
548
549
550@ioprepped
551@dataclass
552class BasicClientUIExpireTime(BasicClientUIComponent):
553    """Show expire-time."""
554
555    time: Annotated[datetime.datetime, IOAttrs('d')]
556    spacing_top: Annotated[float, IOAttrs('st', store_default=False)] = 0.0
557    spacing_bottom: Annotated[float, IOAttrs('sb', store_default=False)] = 0.0
558
559    @override
560    @classmethod
561    def get_type_id(cls) -> BasicClientUIComponentTypeID:
562        return BasicClientUIComponentTypeID.EXPIRE_TIME
563
564
565@ioprepped
566@dataclass
567class BasicClientUI(ClientUI):
568    """A basic UI for the client."""
569
570    class ButtonLabel(Enum):
571        """Distinct button labels we support."""
572
573        UNKNOWN = 'u'
574        OK = 'o'
575        APPLY = 'a'
576        CANCEL = 'c'
577        ACCEPT = 'ac'
578        DECLINE = 'dn'
579        IGNORE = 'ig'
580        CLAIM = 'cl'
581        DISCARD = 'd'
582
583    class InteractionStyle(Enum):
584        """Overall interaction styles we support."""
585
586        UNKNOWN = 'u'
587        BUTTON_POSITIVE = 'p'
588        BUTTON_POSITIVE_NEGATIVE = 'pn'
589
590    components: Annotated[list[BasicClientUIComponent], IOAttrs('s')]
591
592    interaction_style: Annotated[
593        InteractionStyle, IOAttrs('i', enum_fallback=InteractionStyle.UNKNOWN)
594    ] = InteractionStyle.BUTTON_POSITIVE
595
596    button_label_positive: Annotated[
597        ButtonLabel, IOAttrs('p', enum_fallback=ButtonLabel.UNKNOWN)
598    ] = ButtonLabel.OK
599
600    button_label_negative: Annotated[
601        ButtonLabel, IOAttrs('n', enum_fallback=ButtonLabel.UNKNOWN)
602    ] = ButtonLabel.CANCEL
603
604    @override
605    @classmethod
606    def get_type_id(cls) -> ClientUITypeID:
607        return ClientUITypeID.BASIC
608
609    def contains_unknown_elements(self) -> bool:
610        """Whether something within us is an unknown type or enum."""
611        return (
612            self.interaction_style is self.InteractionStyle.UNKNOWN
613            or self.button_label_positive is self.ButtonLabel.UNKNOWN
614            or self.button_label_negative is self.ButtonLabel.UNKNOWN
615            or any(
616                c.get_type_id() is BasicClientUIComponentTypeID.UNKNOWN
617                for c in self.components
618            )
619        )
620
621
622@ioprepped
623@dataclass
624class ClientUIWrapper:
625    """Wrapper for a ClientUI and its common data."""
626
627    id: Annotated[str, IOAttrs('i')]
628    createtime: Annotated[datetime.datetime, IOAttrs('c')]
629    ui: Annotated[ClientUI, IOAttrs('e')]
630
631
632@ioprepped
633@dataclass
634class InboxRequestMessage(Message):
635    """Message requesting our inbox."""
636
637    @override
638    @classmethod
639    def get_response_types(cls) -> list[type[Response] | None]:
640        return [InboxRequestResponse]
641
642
643@ioprepped
644@dataclass
645class InboxRequestResponse(Response):
646    """Here's that inbox contents you asked for, boss."""
647
648    wrappers: Annotated[list[ClientUIWrapper], IOAttrs('w')]
649
650    # Printable error if something goes wrong.
651    error: Annotated[str | None, IOAttrs('e')] = None
652
653
654class ClientUIAction(Enum):
655    """Types of actions we can run."""
656
657    BUTTON_PRESS_POSITIVE = 'p'
658    BUTTON_PRESS_NEGATIVE = 'n'
659
660
661class ClientEffectTypeID(Enum):
662    """Type ID for each of our subclasses."""
663
664    UNKNOWN = 'u'
665    SCREEN_MESSAGE = 'm'
666    SOUND = 's'
667    DELAY = 'd'
668    CHEST_WAIT_TIME_ANIMATION = 't'
669    TICKETS_ANIMATION = 'ta'
670    TOKENS_ANIMATION = 'toa'
671
672
673class ClientEffect(IOMultiType[ClientEffectTypeID]):
674    """Something that can happen on the client.
675
676    This can include screen messages, sounds, visual effects, etc.
677    """
678
679    @override
680    @classmethod
681    def get_type_id(cls) -> ClientEffectTypeID:
682        # Require child classes to supply this themselves. If we did a
683        # full type registry/lookup here it would require us to import
684        # everything and would prevent lazy loading.
685        raise NotImplementedError()
686
687    @override
688    @classmethod
689    def get_type(cls, type_id: ClientEffectTypeID) -> type[ClientEffect]:
690        """Return the subclass for each of our type-ids."""
691        # pylint: disable=cyclic-import
692        # pylint: disable=too-many-return-statements
693
694        t = ClientEffectTypeID
695        if type_id is t.UNKNOWN:
696            return ClientEffectUnknown
697        if type_id is t.SCREEN_MESSAGE:
698            return ClientEffectScreenMessage
699        if type_id is t.SOUND:
700            return ClientEffectSound
701        if type_id is t.DELAY:
702            return ClientEffectDelay
703        if type_id is t.CHEST_WAIT_TIME_ANIMATION:
704            return ClientEffectChestWaitTimeAnimation
705        if type_id is t.TICKETS_ANIMATION:
706            return ClientEffectTicketsAnimation
707        if type_id is t.TOKENS_ANIMATION:
708            return ClientEffectTokensAnimation
709
710        # Important to make sure we provide all types.
711        assert_never(type_id)
712
713    @override
714    @classmethod
715    def get_unknown_type_fallback(cls) -> ClientEffect:
716        # If we encounter some future message type we don't know
717        # anything about, drop in a placeholder.
718        return ClientEffectUnknown()
719
720
721@ioprepped
722@dataclass
723class ClientEffectUnknown(ClientEffect):
724    """Fallback substitute for types we don't recognize."""
725
726    @override
727    @classmethod
728    def get_type_id(cls) -> ClientEffectTypeID:
729        return ClientEffectTypeID.UNKNOWN
730
731
732@ioprepped
733@dataclass
734class ClientEffectScreenMessage(ClientEffect):
735    """Display a screen-message."""
736
737    message: Annotated[str, IOAttrs('m')]
738    subs: Annotated[list[str], IOAttrs('s')]
739    color: Annotated[tuple[float, float, float], IOAttrs('c')] = (1.0, 1.0, 1.0)
740
741    @override
742    @classmethod
743    def get_type_id(cls) -> ClientEffectTypeID:
744        return ClientEffectTypeID.SCREEN_MESSAGE
745
746
747@ioprepped
748@dataclass
749class ClientEffectSound(ClientEffect):
750    """Play a sound."""
751
752    class Sound(Enum):
753        """Sounds that can be made alongside the message."""
754
755        UNKNOWN = 'u'
756        CASH_REGISTER = 'c'
757        ERROR = 'e'
758        POWER_DOWN = 'p'
759        GUN_COCKING = 'g'
760
761    sound: Annotated[Sound, IOAttrs('s', enum_fallback=Sound.UNKNOWN)]
762    volume: Annotated[float, IOAttrs('v')] = 1.0
763
764    @override
765    @classmethod
766    def get_type_id(cls) -> ClientEffectTypeID:
767        return ClientEffectTypeID.SOUND
768
769
770@ioprepped
771@dataclass
772class ClientEffectChestWaitTimeAnimation(ClientEffect):
773    """Animate chest wait time changing."""
774
775    chestid: Annotated[str, IOAttrs('c')]
776    duration: Annotated[float, IOAttrs('u')]
777    startvalue: Annotated[datetime.datetime, IOAttrs('o')]
778    endvalue: Annotated[datetime.datetime, IOAttrs('n')]
779
780    @override
781    @classmethod
782    def get_type_id(cls) -> ClientEffectTypeID:
783        return ClientEffectTypeID.CHEST_WAIT_TIME_ANIMATION
784
785
786@ioprepped
787@dataclass
788class ClientEffectTicketsAnimation(ClientEffect):
789    """Animate tickets count."""
790
791    duration: Annotated[float, IOAttrs('u')]
792    startvalue: Annotated[int, IOAttrs('s')]
793    endvalue: Annotated[int, IOAttrs('e')]
794
795    @override
796    @classmethod
797    def get_type_id(cls) -> ClientEffectTypeID:
798        return ClientEffectTypeID.TICKETS_ANIMATION
799
800
801@ioprepped
802@dataclass
803class ClientEffectTokensAnimation(ClientEffect):
804    """Animate tokens count."""
805
806    duration: Annotated[float, IOAttrs('u')]
807    startvalue: Annotated[int, IOAttrs('s')]
808    endvalue: Annotated[int, IOAttrs('e')]
809
810    @override
811    @classmethod
812    def get_type_id(cls) -> ClientEffectTypeID:
813        return ClientEffectTypeID.TOKENS_ANIMATION
814
815
816@ioprepped
817@dataclass
818class ClientEffectDelay(ClientEffect):
819    """Delay effect processing."""
820
821    seconds: Annotated[float, IOAttrs('s')]
822
823    @override
824    @classmethod
825    def get_type_id(cls) -> ClientEffectTypeID:
826        return ClientEffectTypeID.DELAY
827
828
829@ioprepped
830@dataclass
831class ClientUIActionMessage(Message):
832    """Do something to a client ui."""
833
834    id: Annotated[str, IOAttrs('i')]
835    action: Annotated[ClientUIAction, IOAttrs('a')]
836
837    @override
838    @classmethod
839    def get_response_types(cls) -> list[type[Response] | None]:
840        return [ClientUIActionResponse]
841
842
843@ioprepped
844@dataclass
845class ClientUIActionResponse(Response):
846    """Did something to that inbox entry, boss."""
847
848    class ErrorType(Enum):
849        """Types of errors that may have occurred."""
850
851        # Probably a future error type we don't recognize.
852        UNKNOWN = 'u'
853
854        # Something went wrong on the server, but specifics are not
855        # relevant.
856        INTERNAL = 'i'
857
858        # The entry expired on the server. In various cases such as 'ok'
859        # buttons this can generally be ignored.
860        EXPIRED = 'e'
861
862    error_type: Annotated[
863        ErrorType | None, IOAttrs('et', enum_fallback=ErrorType.UNKNOWN)
864    ]
865
866    # User facing error message in the case of errors.
867    error_message: Annotated[str | None, IOAttrs('em')]
868
869    effects: Annotated[list[ClientEffect], IOAttrs('fx')]
870
871
872@ioprepped
873@dataclass
874class ScoreSubmitMessage(Message):
875    """Let the server know we got some score in something."""
876
877    score_token: Annotated[str, IOAttrs('t')]
878
879    @override
880    @classmethod
881    def get_response_types(cls) -> list[type[Response] | None]:
882        return [ScoreSubmitResponse]
883
884
885@ioprepped
886@dataclass
887class ScoreSubmitResponse(Response):
888    """Did something to that inbox entry, boss."""
889
890    # Things we should show on our end.
891    effects: Annotated[list[ClientEffect], IOAttrs('fx')]
892
893
894@ioprepped
895@dataclass
896class ChestActionMessage(Message):
897    """Request action about a chest."""
898
899    class Action(Enum):
900        """Types of actions we can request."""
901
902        # Unlocking (for free or with tokens).
903        UNLOCK = 'u'
904
905        # Watched an ad to reduce wait.
906        AD = 'ad'
907
908    action: Annotated[Action, IOAttrs('a')]
909
910    # Tokens we are paying (only applies to unlock).
911    token_payment: Annotated[int, IOAttrs('t')]
912
913    chest_id: Annotated[str, IOAttrs('i')]
914
915    @override
916    @classmethod
917    def get_response_types(cls) -> list[type[Response] | None]:
918        return [ChestActionResponse]
919
920
921@ioprepped
922@dataclass
923class ChestActionResponse(Response):
924    """Here's the results of that action you asked for, boss."""
925
926    # Tokens that were actually charged.
927    tokens_charged: Annotated[int, IOAttrs('t')] = 0
928
929    # If present, signifies the chest has been opened and we should show
930    # the user this stuff that was in it.
931    contents: Annotated[list[DisplayItemWrapper] | None, IOAttrs('c')] = None
932
933    # If contents are present, which of the chest's prize-sets they
934    # represent.
935    prizeindex: Annotated[int, IOAttrs('i')] = 0
936
937    # Printable error if something goes wrong.
938    error: Annotated[str | None, IOAttrs('e')] = None
939
940    # Printable warning. Shown in orange with an error sound. Does not
941    # mean the action failed; only that there's something to tell the
942    # users such as 'It looks like you are faking ad views; stop it or
943    # you won't have ad options anymore.'
944    warning: Annotated[str | None, IOAttrs('w', store_default=False)] = None
945
946    # Printable success message. Shown in green with a cash-register
947    # sound. Can be used for things like successful wait reductions via
948    # ad views. Used in builds earlier than 22311; can remove once
949    # 22311+ is ubiquitous.
950    success_msg: Annotated[str | None, IOAttrs('s', store_default=False)] = None
951
952    # Effects to show on the client. Replaces warning and success_msg in
953    # build 22311 or newer.
954    effects: Annotated[
955        list[ClientEffect], IOAttrs('fx', store_default=False)
956    ] = field(default_factory=list)