Added new files

dist/ba_data/python/bastd/ui/league/__init__.py

@@ -0,0 +1,3 @@
+# Released under the MIT License. See LICENSE for details.
+#
+"""League related UI functionality."""

dist/ba_data/python/bastd/ui/league/rankbutton.py

@@ -0,0 +1,426 @@
+# Released under the MIT License. See LICENSE for details.
+#
+"""Provides a button showing league rank."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import ba
+import ba.internal
+
+if TYPE_CHECKING:
+    from typing import Any, Callable
+
+
+class LeagueRankButton:
+    """Button showing league rank."""
+
+    def __init__(
+        self,
+        parent: ba.Widget,
+        position: tuple[float, float],
+        size: tuple[float, float],
+        scale: float,
+        on_activate_call: Callable[[], Any] | None = None,
+        transition_delay: float | None = None,
+        color: tuple[float, float, float] | None = None,
+        textcolor: tuple[float, float, float] | None = None,
+        smooth_update_delay: float | None = None,
+    ):
+        if on_activate_call is None:
+            on_activate_call = ba.WeakCall(self._default_on_activate_call)
+        self._on_activate_call = on_activate_call
+        if smooth_update_delay is None:
+            smooth_update_delay = 1000
+        self._smooth_update_delay = smooth_update_delay
+        self._size = size
+        self._scale = scale
+        if color is None:
+            color = (0.5, 0.6, 0.5)
+        if textcolor is None:
+            textcolor = (1, 1, 1)
+        self._color = color
+        self._textcolor = textcolor
+        self._header_color = (0.8, 0.8, 2.0)
+        self._parent = parent
+        self._position: tuple[float, float] = (0.0, 0.0)
+
+        self._button = ba.buttonwidget(
+            parent=parent,
+            size=size,
+            label='',
+            button_type='square',
+            scale=scale,
+            autoselect=True,
+            on_activate_call=self._on_activate,
+            transition_delay=transition_delay,
+            color=color,
+        )
+
+        self._title_text = ba.textwidget(
+            parent=parent,
+            size=(0, 0),
+            draw_controller=self._button,
+            h_align='center',
+            v_align='center',
+            maxwidth=size[0] * scale * 0.85,
+            text=ba.Lstr(
+                resource='league.leagueRankText',
+                fallback_resource='coopSelectWindow.powerRankingText',
+            ),
+            color=self._header_color,
+            flatness=1.0,
+            shadow=1.0,
+            scale=scale * 0.5,
+            transition_delay=transition_delay,
+        )
+
+        self._value_text = ba.textwidget(
+            parent=parent,
+            size=(0, 0),
+            h_align='center',
+            v_align='center',
+            maxwidth=size[0] * scale * 0.85,
+            text='-',
+            draw_controller=self._button,
+            big=True,
+            scale=scale,
+            transition_delay=transition_delay,
+            color=textcolor,
+        )
+
+        self._smooth_percent: float | None = None
+        self._percent: int | None = None
+        self._smooth_rank: float | None = None
+        self._rank: int | None = None
+        self._ticking_node: ba.Node | None = None
+        self._smooth_increase_speed = 1.0
+        self._league: str | None = None
+        self._improvement_text: str | None = None
+
+        self._smooth_update_timer: ba.Timer | None = None
+
+        # Take note of our account state; we'll refresh later if this changes.
+        self._account_state_num = ba.internal.get_v1_account_state_num()
+        self._last_power_ranking_query_time: float | None = None
+        self._doing_power_ranking_query = False
+        self.set_position(position)
+        self._bg_flash = False
+        self._update_timer = ba.Timer(
+            1.0,
+            ba.WeakCall(self._update),
+            timetype=ba.TimeType.REAL,
+            repeat=True,
+        )
+        self._update()
+
+        # If we've got cached power-ranking data already, apply it.
+        data = ba.app.accounts_v1.get_cached_league_rank_data()
+        if data is not None:
+            self._update_for_league_rank_data(data)
+
+    def _on_activate(self) -> None:
+        ba.internal.increment_analytics_count('League rank button press')
+        self._on_activate_call()
+
+    def __del__(self) -> None:
+        if self._ticking_node is not None:
+            self._ticking_node.delete()
+
+    def _start_smooth_update(self) -> None:
+        self._smooth_update_timer = ba.Timer(
+            0.05,
+            ba.WeakCall(self._smooth_update),
+            repeat=True,
+            timetype=ba.TimeType.REAL,
+        )
+
+    def _smooth_update(self) -> None:
+        # pylint: disable=too-many-branches
+        # pylint: disable=too-many-statements
+        try:
+            if not self._button:
+                return
+            if self._ticking_node is None:
+                with ba.Context('ui'):
+                    self._ticking_node = ba.newnode(
+                        'sound',
+                        attrs={
+                            'sound': ba.getsound('scoreIncrease'),
+                            'positional': False,
+                        },
+                    )
+            self._bg_flash = not self._bg_flash
+            color_used = (
+                (self._color[0] * 2, self._color[1] * 2, self._color[2] * 2)
+                if self._bg_flash
+                else self._color
+            )
+            textcolor_used = (1, 1, 1) if self._bg_flash else self._textcolor
+            header_color_used = (
+                (1, 1, 1) if self._bg_flash else self._header_color
+            )
+
+            if self._rank is not None:
+                assert self._smooth_rank is not None
+                self._smooth_rank -= 1.0 * self._smooth_increase_speed
+                finished = int(self._smooth_rank) <= self._rank
+            elif self._smooth_percent is not None:
+                self._smooth_percent += 1.0 * self._smooth_increase_speed
+                assert self._percent is not None
+                finished = int(self._smooth_percent) >= self._percent
+            else:
+                finished = True
+            if finished:
+                if self._rank is not None:
+                    self._smooth_rank = float(self._rank)
+                elif self._percent is not None:
+                    self._smooth_percent = float(self._percent)
+                color_used = self._color
+                textcolor_used = self._textcolor
+                self._smooth_update_timer = None
+                if self._ticking_node is not None:
+                    self._ticking_node.delete()
+                    self._ticking_node = None
+                ba.playsound(ba.getsound('cashRegister2'))
+                assert self._improvement_text is not None
+                diff_text = ba.textwidget(
+                    parent=self._parent,
+                    size=(0, 0),
+                    h_align='center',
+                    v_align='center',
+                    text='+' + self._improvement_text + '!',
+                    position=(
+                        self._position[0] + self._size[0] * 0.5 * self._scale,
+                        self._position[1] + self._size[1] * -0.2 * self._scale,
+                    ),
+                    color=(0, 1, 0),
+                    flatness=1.0,
+                    shadow=0.0,
+                    scale=self._scale * 0.7,
+                )
+
+                def safe_delete(widget: ba.Widget) -> None:
+                    if widget:
+                        widget.delete()
+
+                ba.timer(
+                    2.0,
+                    ba.Call(safe_delete, diff_text),
+                    timetype=ba.TimeType.REAL,
+                )
+            status_text: str | ba.Lstr
+            if self._rank is not None:
+                assert self._smooth_rank is not None
+                status_text = ba.Lstr(
+                    resource='numberText',
+                    subs=[('${NUMBER}', str(int(self._smooth_rank)))],
+                )
+            elif self._smooth_percent is not None:
+                status_text = str(int(self._smooth_percent)) + '%'
+            else:
+                status_text = '-'
+            ba.textwidget(
+                edit=self._value_text, text=status_text, color=textcolor_used
+            )
+            ba.textwidget(edit=self._title_text, color=header_color_used)
+            ba.buttonwidget(edit=self._button, color=color_used)
+
+        except Exception:
+            ba.print_exception('Error doing smooth update.')
+            self._smooth_update_timer = None
+
+    def _update_for_league_rank_data(self, data: dict[str, Any] | None) -> None:
+        # pylint: disable=too-many-branches
+        # pylint: disable=too-many-statements
+
+        # If our button has died, ignore.
+        if not self._button:
+            return
+
+        status_text: str | ba.Lstr
+
+        in_top = data is not None and data['rank'] is not None
+        do_percent = False
+        if data is None or ba.internal.get_v1_account_state() != 'signed_in':
+            self._percent = self._rank = None
+            status_text = '-'
+        elif in_top:
+            self._percent = None
+            self._rank = data['rank']
+            prev_league = self._league
+            self._league = data['l']
+
+            # If this is the first set, league has changed, or rank has gotten
+            # worse, snap the smooth value immediately.
+            assert self._rank is not None
+            if (
+                self._smooth_rank is None
+                or prev_league != self._league
+                or self._rank > int(self._smooth_rank)
+            ):
+                self._smooth_rank = float(self._rank)
+            status_text = ba.Lstr(
+                resource='numberText',
+                subs=[('${NUMBER}', str(int(self._smooth_rank)))],
+            )
+        else:
+            try:
+                if not data['scores'] or data['scores'][-1][1] <= 0:
+                    self._percent = self._rank = None
+                    status_text = '-'
+                else:
+                    our_points = ba.app.accounts_v1.get_league_rank_points(data)
+                    progress = float(our_points) / data['scores'][-1][1]
+                    self._percent = int(progress * 100.0)
+                    self._rank = None
+                    do_percent = True
+                    prev_league = self._league
+                    self._league = data['l']
+
+                    # If this is the first set, league has changed, or percent
+                    # has decreased, snap the smooth value immediately.
+                    if (
+                        self._smooth_percent is None
+                        or prev_league != self._league
+                        or self._percent < int(self._smooth_percent)
+                    ):
+                        self._smooth_percent = float(self._percent)
+                    status_text = str(int(self._smooth_percent)) + '%'
+
+            except Exception:
+                ba.print_exception('Error updating power ranking.')
+                self._percent = self._rank = None
+                status_text = '-'
+
+        # If we're doing a smooth update, set a timer.
+        if (
+            self._rank is not None
+            and self._smooth_rank is not None
+            and int(self._smooth_rank) != self._rank
+        ):
+            self._improvement_text = str(
+                -(int(self._rank) - int(self._smooth_rank))
+            )
+            diff = abs(self._rank - self._smooth_rank)
+            if diff > 100:
+                self._smooth_increase_speed = diff / 80.0
+            elif diff > 50:
+                self._smooth_increase_speed = diff / 70.0
+            elif diff > 25:
+                self._smooth_increase_speed = diff / 55.0
+            else:
+                self._smooth_increase_speed = diff / 40.0
+            self._smooth_increase_speed = max(0.4, self._smooth_increase_speed)
+            ba.timer(
+                self._smooth_update_delay,
+                ba.WeakCall(self._start_smooth_update),
+                timetype=ba.TimeType.REAL,
+                timeformat=ba.TimeFormat.MILLISECONDS,
+            )
+
+        if (
+            self._percent is not None
+            and self._smooth_percent is not None
+            and int(self._smooth_percent) != self._percent
+        ):
+            self._improvement_text = str(
+                (int(self._percent) - int(self._smooth_percent))
+            )
+            self._smooth_increase_speed = 0.3
+            ba.timer(
+                self._smooth_update_delay,
+                ba.WeakCall(self._start_smooth_update),
+                timetype=ba.TimeType.REAL,
+                timeformat=ba.TimeFormat.MILLISECONDS,
+            )
+
+        if do_percent:
+            ba.textwidget(
+                edit=self._title_text,
+                text=ba.Lstr(resource='coopSelectWindow.toRankedText'),
+            )
+        else:
+            try:
+                assert data is not None
+                txt = ba.Lstr(
+                    resource='league.leagueFullText',
+                    subs=[
+                        (
+                            '${NAME}',
+                            ba.Lstr(translate=('leagueNames', data['l']['n'])),
+                        ),
+                    ],
+                )
+                t_color = data['l']['c']
+            except Exception:
+                txt = ba.Lstr(
+                    resource='league.leagueRankText',
+                    fallback_resource='coopSelectWindow.powerRankingText',
+                )
+                t_color = ba.app.ui.title_color
+            ba.textwidget(edit=self._title_text, text=txt, color=t_color)
+        ba.textwidget(edit=self._value_text, text=status_text)
+
+    def _on_power_ranking_query_response(
+        self, data: dict[str, Any] | None
+    ) -> None:
+        self._doing_power_ranking_query = False
+        ba.app.accounts_v1.cache_league_rank_data(data)
+        self._update_for_league_rank_data(data)
+
+    def _update(self) -> None:
+        cur_time = ba.time(ba.TimeType.REAL)
+
+        # If our account state has changed, refresh our UI.
+        account_state_num = ba.internal.get_v1_account_state_num()
+        if account_state_num != self._account_state_num:
+            self._account_state_num = account_state_num
+
+            # And power ranking too...
+            if not self._doing_power_ranking_query:
+                self._last_power_ranking_query_time = None
+
+        # Send off a new power-ranking query if its been
+        # long enough or whatnot.
+        if not self._doing_power_ranking_query and (
+            self._last_power_ranking_query_time is None
+            or cur_time - self._last_power_ranking_query_time > 30.0
+        ):
+            self._last_power_ranking_query_time = cur_time
+            self._doing_power_ranking_query = True
+            ba.internal.power_ranking_query(
+                callback=ba.WeakCall(self._on_power_ranking_query_response)
+            )
+
+    def _default_on_activate_call(self) -> None:
+        # pylint: disable=cyclic-import
+        from bastd.ui.league.rankwindow import LeagueRankWindow
+
+        LeagueRankWindow(modal=True, origin_widget=self._button)
+
+    def set_position(self, position: tuple[float, float]) -> None:
+        """Set the button's position."""
+        self._position = position
+        if not self._button:
+            return
+        ba.buttonwidget(edit=self._button, position=self._position)
+        ba.textwidget(
+            edit=self._title_text,
+            position=(
+                self._position[0] + self._size[0] * 0.5 * self._scale,
+                self._position[1] + self._size[1] * 0.82 * self._scale,
+            ),
+        )
+        ba.textwidget(
+            edit=self._value_text,
+            position=(
+                self._position[0] + self._size[0] * 0.5 * self._scale,
+                self._position[1] + self._size[1] * 0.36 * self._scale,
+            ),
+        )
+
+    def get_button(self) -> ba.Widget:
+        """Return the underlying button ba.Widget>"""
+        return self._button