bascenev1lib.actor.respawnicon

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Implements respawn icon actor."""
  4
  5from __future__ import annotations
  6
  7import weakref
  8
  9import bascenev1 as bs
 10
 11
 12class RespawnIcon:
 13    """An icon with a countdown that appears alongside the screen.
 14
 15    category: Gameplay Classes
 16
 17    This is used to indicate that a bascenev1.Player is waiting to respawn.
 18    """
 19
 20    _MASKTEXSTORENAME = bs.storagename('masktex')
 21    _ICONSSTORENAME = bs.storagename('icons')
 22
 23    def __init__(self, player: bs.Player, respawn_time: float):
 24        """Instantiate with a Player and respawn_time (in seconds)."""
 25        self._visible = True
 26
 27        on_right, offs_extra, respawn_icons = self._get_context(player)
 28
 29        # Cache our mask tex on the team for easy access.
 30        mask_tex = player.team.customdata.get(self._MASKTEXSTORENAME)
 31        if mask_tex is None:
 32            mask_tex = bs.gettexture('characterIconMask')
 33            player.team.customdata[self._MASKTEXSTORENAME] = mask_tex
 34        assert isinstance(mask_tex, bs.Texture)
 35
 36        # Now find the first unused slot and use that.
 37        index = 0
 38        while (
 39            index in respawn_icons
 40            and respawn_icons[index]() is not None
 41            and respawn_icons[index]().visible
 42        ):
 43            index += 1
 44        respawn_icons[index] = weakref.ref(self)
 45
 46        offs = offs_extra + index * -53
 47        icon = player.get_icon()
 48        texture = icon['texture']
 49        h_offs = -10
 50        ipos = (-40 - h_offs if on_right else 40 + h_offs, -180 + offs)
 51        self._image: bs.NodeActor | None = bs.NodeActor(
 52            bs.newnode(
 53                'image',
 54                attrs={
 55                    'texture': texture,
 56                    'tint_texture': icon['tint_texture'],
 57                    'tint_color': icon['tint_color'],
 58                    'tint2_color': icon['tint2_color'],
 59                    'mask_texture': mask_tex,
 60                    'position': ipos,
 61                    'scale': (32, 32),
 62                    'opacity': 1.0,
 63                    'absolute_scale': True,
 64                    'attach': 'topRight' if on_right else 'topLeft',
 65                },
 66            )
 67        )
 68
 69        assert self._image.node
 70        bs.animate(self._image.node, 'opacity', {0.0: 0, 0.2: 0.7})
 71
 72        npos = (-40 - h_offs if on_right else 40 + h_offs, -205 + 49 + offs)
 73        self._name: bs.NodeActor | None = bs.NodeActor(
 74            bs.newnode(
 75                'text',
 76                attrs={
 77                    'v_attach': 'top',
 78                    'h_attach': 'right' if on_right else 'left',
 79                    'text': bs.Lstr(value=player.getname()),
 80                    'maxwidth': 100,
 81                    'h_align': 'center',
 82                    'v_align': 'center',
 83                    'shadow': 1.0,
 84                    'flatness': 1.0,
 85                    'color': bs.safecolor(icon['tint_color']),
 86                    'scale': 0.5,
 87                    'position': npos,
 88                },
 89            )
 90        )
 91
 92        assert self._name.node
 93        bs.animate(self._name.node, 'scale', {0: 0, 0.1: 0.5})
 94
 95        tpos = (-60 - h_offs if on_right else 60 + h_offs, -192 + offs)
 96        self._text: bs.NodeActor | None = bs.NodeActor(
 97            bs.newnode(
 98                'text',
 99                attrs={
100                    'position': tpos,
101                    'h_attach': 'right' if on_right else 'left',
102                    'h_align': 'right' if on_right else 'left',
103                    'scale': 0.9,
104                    'shadow': 0.5,
105                    'flatness': 0.5,
106                    'v_attach': 'top',
107                    'color': bs.safecolor(icon['tint_color']),
108                    'text': '',
109                },
110            )
111        )
112
113        assert self._text.node
114        bs.animate(self._text.node, 'scale', {0: 0, 0.1: 0.9})
115
116        self._respawn_time = bs.time() + respawn_time
117        self._update()
118        self._timer: bs.Timer | None = bs.Timer(
119            1.0, bs.WeakCall(self._update), repeat=True
120        )
121
122    @property
123    def visible(self) -> bool:
124        """Is this icon still visible?"""
125        return self._visible
126
127    def _get_context(self, player: bs.Player) -> tuple[bool, float, dict]:
128        """Return info on where we should be shown and stored."""
129        activity = bs.getactivity()
130
131        if isinstance(bs.getsession(), bs.DualTeamSession):
132            on_right = player.team.id % 2 == 1
133
134            # Store a list of icons in the team.
135            icons = player.team.customdata.get(self._ICONSSTORENAME)
136            if icons is None:
137                player.team.customdata[self._ICONSSTORENAME] = icons = {}
138            assert isinstance(icons, dict)
139
140            offs_extra = -20
141        else:
142            on_right = False
143
144            # Store a list of icons in the activity.
145            icons = activity.customdata.get(self._ICONSSTORENAME)
146            if icons is None:
147                activity.customdata[self._ICONSSTORENAME] = icons = {}
148            assert isinstance(icons, dict)
149
150            if isinstance(activity.session, bs.FreeForAllSession):
151                offs_extra = -150
152            else:
153                offs_extra = -20
154        return on_right, offs_extra, icons
155
156    def _update(self) -> None:
157        remaining = int(round(self._respawn_time - bs.time()))
158        if remaining > 0:
159            assert self._text is not None
160            if self._text.node:
161                self._text.node.text = str(remaining)
162        else:
163            self._visible = False
164            self._image = self._text = self._timer = self._name = None