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