bascenev1lib.actor.popuptext

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Defines Actor(s)."""
  4
  5from __future__ import annotations
  6
  7import random
  8from typing import TYPE_CHECKING, override
  9
 10import bascenev1 as bs
 11
 12if TYPE_CHECKING:
 13    from typing import Any, Sequence
 14
 15
 16class PopupText(bs.Actor):
 17    """Text that pops up above a position to denote something special.
 18
 19    category: Gameplay Classes
 20    """
 21
 22    def __init__(
 23        self,
 24        text: str | bs.Lstr,
 25        position: Sequence[float] = (0.0, 0.0, 0.0),
 26        color: Sequence[float] = (1.0, 1.0, 1.0, 1.0),
 27        random_offset: float = 0.5,
 28        offset: Sequence[float] = (0.0, 0.0, 0.0),
 29        scale: float = 1.0,
 30    ):
 31        """Instantiate with given values.
 32
 33        random_offset is the amount of random offset from the provided position
 34        that will be applied. This can help multiple achievements from
 35        overlapping too much.
 36        """
 37        super().__init__()
 38        if len(color) == 3:
 39            color = (color[0], color[1], color[2], 1.0)
 40        pos = (
 41            position[0] + offset[0] + random_offset * (0.5 - random.random()),
 42            position[1] + offset[1] + random_offset * (0.5 - random.random()),
 43            position[2] + offset[2] + random_offset * (0.5 - random.random()),
 44        )
 45
 46        self.node = bs.newnode(
 47            'text',
 48            attrs={
 49                'text': text,
 50                'in_world': True,
 51                'shadow': 1.0,
 52                'flatness': 1.0,
 53                'h_align': 'center',
 54            },
 55            delegate=self,
 56        )
 57
 58        lifespan = 1.5
 59
 60        # scale up
 61        bs.animate(
 62            self.node,
 63            'scale',
 64            {
 65                0: 0.0,
 66                lifespan * 0.11: 0.020 * 0.7 * scale,
 67                lifespan * 0.16: 0.013 * 0.7 * scale,
 68                lifespan * 0.25: 0.014 * 0.7 * scale,
 69            },
 70        )
 71
 72        # translate upward
 73        self._tcombine = bs.newnode(
 74            'combine',
 75            owner=self.node,
 76            attrs={'input0': pos[0], 'input2': pos[2], 'size': 3},
 77        )
 78        bs.animate(
 79            self._tcombine, 'input1', {0: pos[1] + 1.5, lifespan: pos[1] + 2.0}
 80        )
 81        self._tcombine.connectattr('output', self.node, 'position')
 82
 83        # fade our opacity in/out
 84        self._combine = bs.newnode(
 85            'combine',
 86            owner=self.node,
 87            attrs={
 88                'input0': color[0],
 89                'input1': color[1],
 90                'input2': color[2],
 91                'size': 4,
 92            },
 93        )
 94        for i in range(4):
 95            bs.animate(
 96                self._combine,
 97                'input' + str(i),
 98                {
 99                    0.13 * lifespan: color[i],
100                    0.18 * lifespan: 4.0 * color[i],
101                    0.22 * lifespan: color[i],
102                },
103            )
104        bs.animate(
105            self._combine,
106            'input3',
107            {
108                0: 0,
109                0.1 * lifespan: color[3],
110                0.7 * lifespan: color[3],
111                lifespan: 0,
112            },
113        )
114        self._combine.connectattr('output', self.node, 'color')
115
116        # kill ourself
117        self._die_timer = bs.Timer(
118            lifespan, bs.WeakCall(self.handlemessage, bs.DieMessage())
119        )
120
121    @override
122    def handlemessage(self, msg: Any) -> Any:
123        assert not self.expired
124        if isinstance(msg, bs.DieMessage):
125            if self.node:
126                self.node.delete()
127        else:
128            super().handlemessage(msg)