bascenev1lib.actor.spaz

   1# Released under the MIT License. See LICENSE for details.
   2#
   3"""Defines the spaz actor."""
   4# pylint: disable=too-many-lines
   5
   6from __future__ import annotations
   7
   8import random
   9import logging
  10from typing import TYPE_CHECKING, override
  11
  12import bascenev1 as bs
  13
  14from bascenev1lib.actor.bomb import Bomb, Blast
  15from bascenev1lib.actor.powerupbox import PowerupBoxFactory, PowerupBox
  16from bascenev1lib.actor.spazfactory import SpazFactory
  17from bascenev1lib.gameutils import SharedObjects
  18
  19if TYPE_CHECKING:
  20    from typing import Any, Sequence, Callable
  21
  22POWERUP_WEAR_OFF_TIME = 20000
  23
  24# Obsolete - just used for demo guy now.
  25BASE_PUNCH_POWER_SCALE = 1.2
  26BASE_PUNCH_COOLDOWN = 400
  27
  28
  29class PickupMessage:
  30    """We wanna pick something up."""
  31
  32
  33class PunchHitMessage:
  34    """Message saying an object was hit."""
  35
  36
  37class CurseExplodeMessage:
  38    """We are cursed and should blow up now."""
  39
  40
  41class BombDiedMessage:
  42    """A bomb has died and thus can be recycled."""
  43
  44
  45class Spaz(bs.Actor):
  46    """
  47    Base class for various Spazzes.
  48
  49    Category: **Gameplay Classes**
  50
  51    A Spaz is the standard little humanoid character in the game.
  52    It can be controlled by a player or by AI, and can have
  53    various different appearances.  The name 'Spaz' is not to be
  54    confused with the 'Spaz' character in the game, which is just
  55    one of the skins available for instances of this class.
  56    """
  57
  58    # pylint: disable=too-many-public-methods
  59    # pylint: disable=too-many-locals
  60
  61    node: bs.Node
  62    """The 'spaz' bs.Node."""
  63
  64    points_mult = 1
  65    curse_time: float | None = 5.0
  66    default_bomb_count = 1
  67    default_bomb_type = 'normal'
  68    default_boxing_gloves = False
  69    default_shields = False
  70    default_hitpoints = 1000
  71
  72    def __init__(
  73        self,
  74        *,
  75        color: Sequence[float] = (1.0, 1.0, 1.0),
  76        highlight: Sequence[float] = (0.5, 0.5, 0.5),
  77        character: str = 'Spaz',
  78        source_player: bs.Player | None = None,
  79        start_invincible: bool = True,
  80        can_accept_powerups: bool = True,
  81        powerups_expire: bool = False,
  82        demo_mode: bool = False,
  83    ):
  84        """Create a spaz with the requested color, character, etc."""
  85        # pylint: disable=too-many-statements
  86
  87        super().__init__()
  88        shared = SharedObjects.get()
  89        activity = self.activity
  90
  91        factory = SpazFactory.get()
  92
  93        # We need to behave slightly different in the tutorial.
  94        self._demo_mode = demo_mode
  95
  96        self.play_big_death_sound = False
  97
  98        # Scales how much impacts affect us (most damage calcs).
  99        self.impact_scale = 1.0
 100
 101        self.source_player = source_player
 102        self._dead = False
 103        if self._demo_mode:  # Preserve old behavior.
 104            self._punch_power_scale = BASE_PUNCH_POWER_SCALE
 105        else:
 106            self._punch_power_scale = factory.punch_power_scale
 107        self.fly = bs.getactivity().globalsnode.happy_thoughts_mode
 108        if isinstance(activity, bs.GameActivity):
 109            self._hockey = activity.map.is_hockey
 110        else:
 111            self._hockey = False
 112        self._punched_nodes: set[bs.Node] = set()
 113        self._cursed = False
 114        self._connected_to_player: bs.Player | None = None
 115        materials = [
 116            factory.spaz_material,
 117            shared.object_material,
 118            shared.player_material,
 119        ]
 120        roller_materials = [factory.roller_material, shared.player_material]
 121        extras_material = []
 122
 123        if can_accept_powerups:
 124            pam = PowerupBoxFactory.get().powerup_accept_material
 125            materials.append(pam)
 126            roller_materials.append(pam)
 127            extras_material.append(pam)
 128
 129        media = factory.get_media(character)
 130        punchmats = (factory.punch_material, shared.attack_material)
 131        pickupmats = (factory.pickup_material, shared.pickup_material)
 132        self.node: bs.Node = bs.newnode(
 133            type='spaz',
 134            delegate=self,
 135            attrs={
 136                'color': color,
 137                'behavior_version': 0 if demo_mode else 1,
 138                'demo_mode': demo_mode,
 139                'highlight': highlight,
 140                'jump_sounds': media['jump_sounds'],
 141                'attack_sounds': media['attack_sounds'],
 142                'impact_sounds': media['impact_sounds'],
 143                'death_sounds': media['death_sounds'],
 144                'pickup_sounds': media['pickup_sounds'],
 145                'fall_sounds': media['fall_sounds'],
 146                'color_texture': media['color_texture'],
 147                'color_mask_texture': media['color_mask_texture'],
 148                'head_mesh': media['head_mesh'],
 149                'torso_mesh': media['torso_mesh'],
 150                'pelvis_mesh': media['pelvis_mesh'],
 151                'upper_arm_mesh': media['upper_arm_mesh'],
 152                'forearm_mesh': media['forearm_mesh'],
 153                'hand_mesh': media['hand_mesh'],
 154                'upper_leg_mesh': media['upper_leg_mesh'],
 155                'lower_leg_mesh': media['lower_leg_mesh'],
 156                'toes_mesh': media['toes_mesh'],
 157                'style': factory.get_style(character),
 158                'fly': self.fly,
 159                'hockey': self._hockey,
 160                'materials': materials,
 161                'roller_materials': roller_materials,
 162                'extras_material': extras_material,
 163                'punch_materials': punchmats,
 164                'pickup_materials': pickupmats,
 165                'invincible': start_invincible,
 166                'source_player': source_player,
 167            },
 168        )
 169        self.shield: bs.Node | None = None
 170
 171        if start_invincible:
 172
 173            def _safesetattr(node: bs.Node | None, attr: str, val: Any) -> None:
 174                if node:
 175                    setattr(node, attr, val)
 176
 177            bs.timer(1.0, bs.Call(_safesetattr, self.node, 'invincible', False))
 178        self.hitpoints = self.default_hitpoints
 179        self.hitpoints_max = self.default_hitpoints
 180        self.shield_hitpoints: int | None = None
 181        self.shield_hitpoints_max = 650
 182        self.shield_decay_rate = 0
 183        self.shield_decay_timer: bs.Timer | None = None
 184        self._boxing_gloves_wear_off_timer: bs.Timer | None = None
 185        self._boxing_gloves_wear_off_flash_timer: bs.Timer | None = None
 186        self._bomb_wear_off_timer: bs.Timer | None = None
 187        self._bomb_wear_off_flash_timer: bs.Timer | None = None
 188        self._multi_bomb_wear_off_timer: bs.Timer | None = None
 189        self._multi_bomb_wear_off_flash_timer: bs.Timer | None = None
 190        self._curse_timer: bs.Timer | None = None
 191        self.bomb_count = self.default_bomb_count
 192        self._max_bomb_count = self.default_bomb_count
 193        self.bomb_type_default = self.default_bomb_type
 194        self.bomb_type = self.bomb_type_default
 195        self.land_mine_count = 0
 196        self.blast_radius = 2.0
 197        self.powerups_expire = powerups_expire
 198        if self._demo_mode:  # Preserve old behavior.
 199            self._punch_cooldown = BASE_PUNCH_COOLDOWN
 200        else:
 201            self._punch_cooldown = factory.punch_cooldown
 202        self._jump_cooldown = 250
 203        self._pickup_cooldown = 0
 204        self._bomb_cooldown = 0
 205        self._has_boxing_gloves = False
 206        if self.default_boxing_gloves:
 207            self.equip_boxing_gloves()
 208        self.last_punch_time_ms = -9999
 209        self.last_pickup_time_ms = -9999
 210        self.last_jump_time_ms = -9999
 211        self.last_run_time_ms = -9999
 212        self._last_run_value = 0.0
 213        self.last_bomb_time_ms = -9999
 214        self._turbo_filter_times: dict[str, int] = {}
 215        self._turbo_filter_time_bucket = 0
 216        self._turbo_filter_counts: dict[str, int] = {}
 217        self.frozen = False
 218        self.shattered = False
 219        self._last_hit_time: int | None = None
 220        self._num_times_hit = 0
 221        self._bomb_held = False
 222        if self.default_shields:
 223            self.equip_shields()
 224        self._dropped_bomb_callbacks: list[Callable[[Spaz, bs.Actor], Any]] = []
 225
 226        self._score_text: bs.Node | None = None
 227        self._score_text_hide_timer: bs.Timer | None = None
 228        self._last_stand_pos: Sequence[float] | None = None
 229
 230        # Deprecated stuff.. should make these into lists.
 231        self.punch_callback: Callable[[Spaz], Any] | None = None
 232        self.pick_up_powerup_callback: Callable[[Spaz], Any] | None = None
 233
 234    @override
 235    def exists(self) -> bool:
 236        return bool(self.node)
 237
 238    @override
 239    def on_expire(self) -> None:
 240        super().on_expire()
 241
 242        # Release callbacks/refs so we don't wind up with dependency loops.
 243        self._dropped_bomb_callbacks = []
 244        self.punch_callback = None
 245        self.pick_up_powerup_callback = None
 246
 247    def add_dropped_bomb_callback(
 248        self, call: Callable[[Spaz, bs.Actor], Any]
 249    ) -> None:
 250        """
 251        Add a call to be run whenever this Spaz drops a bomb.
 252        The spaz and the newly-dropped bomb are passed as arguments.
 253        """
 254        assert not self.expired
 255        self._dropped_bomb_callbacks.append(call)
 256
 257    @override
 258    def is_alive(self) -> bool:
 259        """
 260        Method override; returns whether ol' spaz is still kickin'.
 261        """
 262        return not self._dead
 263
 264    def _hide_score_text(self) -> None:
 265        if self._score_text:
 266            assert isinstance(self._score_text.scale, float)
 267            bs.animate(
 268                self._score_text,
 269                'scale',
 270                {0.0: self._score_text.scale, 0.2: 0.0},
 271            )
 272
 273    def _turbo_filter_add_press(self, source: str) -> None:
 274        """
 275        Can pass all button presses through here; if we see an obscene number
 276        of them in a short time let's shame/pushish this guy for using turbo.
 277        """
 278        t_ms = int(bs.basetime() * 1000.0)
 279        assert isinstance(t_ms, int)
 280        t_bucket = int(t_ms / 1000)
 281        if t_bucket == self._turbo_filter_time_bucket:
 282            # Add only once per timestep (filter out buttons triggering
 283            # multiple actions).
 284            if t_ms != self._turbo_filter_times.get(source, 0):
 285                self._turbo_filter_counts[source] = (
 286                    self._turbo_filter_counts.get(source, 0) + 1
 287                )
 288                self._turbo_filter_times[source] = t_ms
 289                # (uncomment to debug; prints what this count is at)
 290                # bs.broadcastmessage( str(source) + " "
 291                #                   + str(self._turbo_filter_counts[source]))
 292                if self._turbo_filter_counts[source] == 15:
 293                    # Knock 'em out.  That'll learn 'em.
 294                    assert self.node
 295                    self.node.handlemessage('knockout', 500.0)
 296
 297                    # Also issue periodic notices about who is turbo-ing.
 298                    now = bs.apptime()
 299                    assert bs.app.classic is not None
 300                    if now > bs.app.classic.last_spaz_turbo_warn_time + 30.0:
 301                        bs.app.classic.last_spaz_turbo_warn_time = now
 302                        bs.broadcastmessage(
 303                            bs.Lstr(
 304                                translate=(
 305                                    'statements',
 306                                    (
 307                                        'Warning to ${NAME}:  '
 308                                        'turbo / button-spamming knocks'
 309                                        ' you out.'
 310                                    ),
 311                                ),
 312                                subs=[('${NAME}', self.node.name)],
 313                            ),
 314                            color=(1, 0.5, 0),
 315                        )
 316                        bs.getsound('error').play()
 317        else:
 318            self._turbo_filter_times = {}
 319            self._turbo_filter_time_bucket = t_bucket
 320            self._turbo_filter_counts = {source: 1}
 321
 322    def set_score_text(
 323        self,
 324        text: str | bs.Lstr,
 325        color: Sequence[float] = (1.0, 1.0, 0.4),
 326        flash: bool = False,
 327    ) -> None:
 328        """
 329        Utility func to show a message momentarily over our spaz that follows
 330        him around; Handy for score updates and things.
 331        """
 332        color_fin = bs.safecolor(color)[:3]
 333        if not self.node:
 334            return
 335        if not self._score_text:
 336            start_scale = 0.0
 337            mnode = bs.newnode(
 338                'math',
 339                owner=self.node,
 340                attrs={'input1': (0, 1.4, 0), 'operation': 'add'},
 341            )
 342            self.node.connectattr('torso_position', mnode, 'input2')
 343            self._score_text = bs.newnode(
 344                'text',
 345                owner=self.node,
 346                attrs={
 347                    'text': text,
 348                    'in_world': True,
 349                    'shadow': 1.0,
 350                    'flatness': 1.0,
 351                    'color': color_fin,
 352                    'scale': 0.02,
 353                    'h_align': 'center',
 354                },
 355            )
 356            mnode.connectattr('output', self._score_text, 'position')
 357        else:
 358            self._score_text.color = color_fin
 359            assert isinstance(self._score_text.scale, float)
 360            start_scale = self._score_text.scale
 361            self._score_text.text = text
 362        if flash:
 363            combine = bs.newnode(
 364                'combine', owner=self._score_text, attrs={'size': 3}
 365            )
 366            scl = 1.8
 367            offs = 0.5
 368            tval = 0.300
 369            for i in range(3):
 370                cl1 = offs + scl * color_fin[i]
 371                cl2 = color_fin[i]
 372                bs.animate(
 373                    combine,
 374                    'input' + str(i),
 375                    {0.5 * tval: cl2, 0.75 * tval: cl1, 1.0 * tval: cl2},
 376                )
 377            combine.connectattr('output', self._score_text, 'color')
 378
 379        bs.animate(self._score_text, 'scale', {0.0: start_scale, 0.2: 0.02})
 380        self._score_text_hide_timer = bs.Timer(
 381            1.0, bs.WeakCall(self._hide_score_text)
 382        )
 383
 384    def on_jump_press(self) -> None:
 385        """
 386        Called to 'press jump' on this spaz;
 387        used by player or AI connections.
 388        """
 389        if not self.node:
 390            return
 391        t_ms = int(bs.time() * 1000.0)
 392        assert isinstance(t_ms, int)
 393        if t_ms - self.last_jump_time_ms >= self._jump_cooldown:
 394            self.node.jump_pressed = True
 395            self.last_jump_time_ms = t_ms
 396        self._turbo_filter_add_press('jump')
 397
 398    def on_jump_release(self) -> None:
 399        """
 400        Called to 'release jump' on this spaz;
 401        used by player or AI connections.
 402        """
 403        if not self.node:
 404            return
 405        self.node.jump_pressed = False
 406
 407    def on_pickup_press(self) -> None:
 408        """
 409        Called to 'press pick-up' on this spaz;
 410        used by player or AI connections.
 411        """
 412        if not self.node:
 413            return
 414        t_ms = int(bs.time() * 1000.0)
 415        assert isinstance(t_ms, int)
 416        if t_ms - self.last_pickup_time_ms >= self._pickup_cooldown:
 417            self.node.pickup_pressed = True
 418            self.last_pickup_time_ms = t_ms
 419        self._turbo_filter_add_press('pickup')
 420
 421    def on_pickup_release(self) -> None:
 422        """
 423        Called to 'release pick-up' on this spaz;
 424        used by player or AI connections.
 425        """
 426        if not self.node:
 427            return
 428        self.node.pickup_pressed = False
 429
 430    def on_hold_position_press(self) -> None:
 431        """
 432        Called to 'press hold-position' on this spaz;
 433        used for player or AI connections.
 434        """
 435        if not self.node:
 436            return
 437        self.node.hold_position_pressed = True
 438        self._turbo_filter_add_press('holdposition')
 439
 440    def on_hold_position_release(self) -> None:
 441        """
 442        Called to 'release hold-position' on this spaz;
 443        used for player or AI connections.
 444        """
 445        if not self.node:
 446            return
 447        self.node.hold_position_pressed = False
 448
 449    def on_punch_press(self) -> None:
 450        """
 451        Called to 'press punch' on this spaz;
 452        used for player or AI connections.
 453        """
 454        if not self.node or self.frozen or self.node.knockout > 0.0:
 455            return
 456        t_ms = int(bs.time() * 1000.0)
 457        assert isinstance(t_ms, int)
 458        if t_ms - self.last_punch_time_ms >= self._punch_cooldown:
 459            if self.punch_callback is not None:
 460                self.punch_callback(self)
 461            self._punched_nodes = set()  # Reset this.
 462            self.last_punch_time_ms = t_ms
 463            self.node.punch_pressed = True
 464            if not self.node.hold_node:
 465                bs.timer(
 466                    0.1,
 467                    bs.WeakCall(
 468                        self._safe_play_sound,
 469                        SpazFactory.get().swish_sound,
 470                        0.8,
 471                    ),
 472                )
 473        self._turbo_filter_add_press('punch')
 474
 475    def _safe_play_sound(self, sound: bs.Sound, volume: float) -> None:
 476        """Plays a sound at our position if we exist."""
 477        if self.node:
 478            sound.play(volume, self.node.position)
 479
 480    def on_punch_release(self) -> None:
 481        """
 482        Called to 'release punch' on this spaz;
 483        used for player or AI connections.
 484        """
 485        if not self.node:
 486            return
 487        self.node.punch_pressed = False
 488
 489    def on_bomb_press(self) -> None:
 490        """
 491        Called to 'press bomb' on this spaz;
 492        used for player or AI connections.
 493        """
 494        if (
 495            not self.node
 496            or self._dead
 497            or self.frozen
 498            or self.node.knockout > 0.0
 499        ):
 500            return
 501        t_ms = int(bs.time() * 1000.0)
 502        assert isinstance(t_ms, int)
 503        if t_ms - self.last_bomb_time_ms >= self._bomb_cooldown:
 504            self.last_bomb_time_ms = t_ms
 505            self.node.bomb_pressed = True
 506            if not self.node.hold_node:
 507                self.drop_bomb()
 508        self._turbo_filter_add_press('bomb')
 509
 510    def on_bomb_release(self) -> None:
 511        """
 512        Called to 'release bomb' on this spaz;
 513        used for player or AI connections.
 514        """
 515        if not self.node:
 516            return
 517        self.node.bomb_pressed = False
 518
 519    def on_run(self, value: float) -> None:
 520        """
 521        Called to 'press run' on this spaz;
 522        used for player or AI connections.
 523        """
 524        if not self.node:
 525            return
 526        t_ms = int(bs.time() * 1000.0)
 527        assert isinstance(t_ms, int)
 528        self.last_run_time_ms = t_ms
 529        self.node.run = value
 530
 531        # Filtering these events would be tough since its an analog
 532        # value, but lets still pass full 0-to-1 presses along to
 533        # the turbo filter to punish players if it looks like they're turbo-ing.
 534        if self._last_run_value < 0.01 and value > 0.99:
 535            self._turbo_filter_add_press('run')
 536
 537        self._last_run_value = value
 538
 539    def on_fly_press(self) -> None:
 540        """
 541        Called to 'press fly' on this spaz;
 542        used for player or AI connections.
 543        """
 544        if not self.node:
 545            return
 546        # Not adding a cooldown time here for now; slightly worried
 547        # input events get clustered up during net-games and we'd wind up
 548        # killing a lot and making it hard to fly.. should look into this.
 549        self.node.fly_pressed = True
 550        self._turbo_filter_add_press('fly')
 551
 552    def on_fly_release(self) -> None:
 553        """
 554        Called to 'release fly' on this spaz;
 555        used for player or AI connections.
 556        """
 557        if not self.node:
 558            return
 559        self.node.fly_pressed = False
 560
 561    def on_move(self, x: float, y: float) -> None:
 562        """
 563        Called to set the joystick amount for this spaz;
 564        used for player or AI connections.
 565        """
 566        if not self.node:
 567            return
 568        self.node.handlemessage('move', x, y)
 569
 570    def on_move_up_down(self, value: float) -> None:
 571        """
 572        Called to set the up/down joystick amount on this spaz;
 573        used for player or AI connections.
 574        value will be between -32768 to 32767
 575        WARNING: deprecated; use on_move instead.
 576        """
 577        if not self.node:
 578            return
 579        self.node.move_up_down = value
 580
 581    def on_move_left_right(self, value: float) -> None:
 582        """
 583        Called to set the left/right joystick amount on this spaz;
 584        used for player or AI connections.
 585        value will be between -32768 to 32767
 586        WARNING: deprecated; use on_move instead.
 587        """
 588        if not self.node:
 589            return
 590        self.node.move_left_right = value
 591
 592    def on_punched(self, damage: int) -> None:
 593        """Called when this spaz gets punched."""
 594
 595    def get_death_points(self, how: bs.DeathType) -> tuple[int, int]:
 596        """Get the points awarded for killing this spaz."""
 597        del how  # Unused.
 598        num_hits = float(max(1, self._num_times_hit))
 599
 600        # Base points is simply 10 for 1-hit-kills and 5 otherwise.
 601        importance = 2 if num_hits < 2 else 1
 602        return (10 if num_hits < 2 else 5) * self.points_mult, importance
 603
 604    def curse(self) -> None:
 605        """
 606        Give this poor spaz a curse;
 607        he will explode in 5 seconds.
 608        """
 609        if not self._cursed:
 610            factory = SpazFactory.get()
 611            self._cursed = True
 612
 613            # Add the curse material.
 614            for attr in ['materials', 'roller_materials']:
 615                materials = getattr(self.node, attr)
 616                if factory.curse_material not in materials:
 617                    setattr(
 618                        self.node, attr, materials + (factory.curse_material,)
 619                    )
 620
 621            # None specifies no time limit.
 622            assert self.node
 623            if self.curse_time is None:
 624                self.node.curse_death_time = -1
 625            else:
 626                # Note: curse-death-time takes milliseconds.
 627                tval = bs.time()
 628                assert isinstance(tval, (float, int))
 629                self.node.curse_death_time = int(
 630                    1000.0 * (tval + self.curse_time)
 631                )
 632                self._curse_timer = bs.Timer(
 633                    self.curse_time,
 634                    bs.WeakCall(self.handlemessage, CurseExplodeMessage()),
 635                )
 636
 637    def equip_boxing_gloves(self) -> None:
 638        """
 639        Give this spaz some boxing gloves.
 640        """
 641        assert self.node
 642        self.node.boxing_gloves = True
 643        self._has_boxing_gloves = True
 644        if self._demo_mode:  # Preserve old behavior.
 645            self._punch_power_scale = 1.7
 646            self._punch_cooldown = 300
 647        else:
 648            factory = SpazFactory.get()
 649            self._punch_power_scale = factory.punch_power_scale_gloves
 650            self._punch_cooldown = factory.punch_cooldown_gloves
 651
 652    def equip_shields(self, decay: bool = False) -> None:
 653        """
 654        Give this spaz a nice energy shield.
 655        """
 656
 657        if not self.node:
 658            logging.exception('Can\'t equip shields; no node.')
 659            return
 660
 661        factory = SpazFactory.get()
 662        if self.shield is None:
 663            self.shield = bs.newnode(
 664                'shield',
 665                owner=self.node,
 666                attrs={'color': (0.3, 0.2, 2.0), 'radius': 1.3},
 667            )
 668            self.node.connectattr('position_center', self.shield, 'position')
 669        self.shield_hitpoints = self.shield_hitpoints_max = 650
 670        self.shield_decay_rate = factory.shield_decay_rate if decay else 0
 671        self.shield.hurt = 0
 672        factory.shield_up_sound.play(1.0, position=self.node.position)
 673
 674        if self.shield_decay_rate > 0:
 675            self.shield_decay_timer = bs.Timer(
 676                0.5, bs.WeakCall(self.shield_decay), repeat=True
 677            )
 678            # So user can see the decay.
 679            self.shield.always_show_health_bar = True
 680
 681    def shield_decay(self) -> None:
 682        """Called repeatedly to decay shield HP over time."""
 683        if self.shield:
 684            assert self.shield_hitpoints is not None
 685            self.shield_hitpoints = max(
 686                0, self.shield_hitpoints - self.shield_decay_rate
 687            )
 688            assert self.shield_hitpoints is not None
 689            self.shield.hurt = (
 690                1.0 - float(self.shield_hitpoints) / self.shield_hitpoints_max
 691            )
 692            if self.shield_hitpoints <= 0:
 693                self.shield.delete()
 694                self.shield = None
 695                self.shield_decay_timer = None
 696                assert self.node
 697                SpazFactory.get().shield_down_sound.play(
 698                    1.0,
 699                    position=self.node.position,
 700                )
 701        else:
 702            self.shield_decay_timer = None
 703
 704    @override
 705    def handlemessage(self, msg: Any) -> Any:
 706        # pylint: disable=too-many-return-statements
 707        # pylint: disable=too-many-statements
 708        # pylint: disable=too-many-branches
 709        assert not self.expired
 710
 711        if isinstance(msg, bs.PickedUpMessage):
 712            if self.node:
 713                self.node.handlemessage('hurt_sound')
 714                self.node.handlemessage('picked_up')
 715
 716            # This counts as a hit.
 717            self._num_times_hit += 1
 718
 719        elif isinstance(msg, bs.ShouldShatterMessage):
 720            # Eww; seems we have to do this in a timer or it wont work right.
 721            # (since we're getting called from within update() perhaps?..)
 722            # NOTE: should test to see if that's still the case.
 723            bs.timer(0.001, bs.WeakCall(self.shatter))
 724
 725        elif isinstance(msg, bs.ImpactDamageMessage):
 726            # Eww; seems we have to do this in a timer or it wont work right.
 727            # (since we're getting called from within update() perhaps?..)
 728            bs.timer(0.001, bs.WeakCall(self._hit_self, msg.intensity))
 729
 730        elif isinstance(msg, bs.PowerupMessage):
 731            if self._dead or not self.node:
 732                return True
 733            if self.pick_up_powerup_callback is not None:
 734                self.pick_up_powerup_callback(self)
 735            if msg.poweruptype == 'triple_bombs':
 736                tex = PowerupBoxFactory.get().tex_bomb
 737                self._flash_billboard(tex)
 738                self.set_bomb_count(3)
 739                if self.powerups_expire:
 740                    self.node.mini_billboard_1_texture = tex
 741                    t_ms = int(bs.time() * 1000.0)
 742                    assert isinstance(t_ms, int)
 743                    self.node.mini_billboard_1_start_time = t_ms
 744                    self.node.mini_billboard_1_end_time = (
 745                        t_ms + POWERUP_WEAR_OFF_TIME
 746                    )
 747                    self._multi_bomb_wear_off_flash_timer = bs.Timer(
 748                        (POWERUP_WEAR_OFF_TIME - 2000) / 1000.0,
 749                        bs.WeakCall(self._multi_bomb_wear_off_flash),
 750                    )
 751                    self._multi_bomb_wear_off_timer = bs.Timer(
 752                        POWERUP_WEAR_OFF_TIME / 1000.0,
 753                        bs.WeakCall(self._multi_bomb_wear_off),
 754                    )
 755            elif msg.poweruptype == 'land_mines':
 756                self.set_land_mine_count(min(self.land_mine_count + 3, 3))
 757            elif msg.poweruptype == 'impact_bombs':
 758                self.bomb_type = 'impact'
 759                tex = self._get_bomb_type_tex()
 760                self._flash_billboard(tex)
 761                if self.powerups_expire:
 762                    self.node.mini_billboard_2_texture = tex
 763                    t_ms = int(bs.time() * 1000.0)
 764                    assert isinstance(t_ms, int)
 765                    self.node.mini_billboard_2_start_time = t_ms
 766                    self.node.mini_billboard_2_end_time = (
 767                        t_ms + POWERUP_WEAR_OFF_TIME
 768                    )
 769                    self._bomb_wear_off_flash_timer = bs.Timer(
 770                        (POWERUP_WEAR_OFF_TIME - 2000) / 1000.0,
 771                        bs.WeakCall(self._bomb_wear_off_flash),
 772                    )
 773                    self._bomb_wear_off_timer = bs.Timer(
 774                        POWERUP_WEAR_OFF_TIME / 1000.0,
 775                        bs.WeakCall(self._bomb_wear_off),
 776                    )
 777            elif msg.poweruptype == 'sticky_bombs':
 778                self.bomb_type = 'sticky'
 779                tex = self._get_bomb_type_tex()
 780                self._flash_billboard(tex)
 781                if self.powerups_expire:
 782                    self.node.mini_billboard_2_texture = tex
 783                    t_ms = int(bs.time() * 1000.0)
 784                    assert isinstance(t_ms, int)
 785                    self.node.mini_billboard_2_start_time = t_ms
 786                    self.node.mini_billboard_2_end_time = (
 787                        t_ms + POWERUP_WEAR_OFF_TIME
 788                    )
 789                    self._bomb_wear_off_flash_timer = bs.Timer(
 790                        (POWERUP_WEAR_OFF_TIME - 2000) / 1000.0,
 791                        bs.WeakCall(self._bomb_wear_off_flash),
 792                    )
 793                    self._bomb_wear_off_timer = bs.Timer(
 794                        POWERUP_WEAR_OFF_TIME / 1000.0,
 795                        bs.WeakCall(self._bomb_wear_off),
 796                    )
 797            elif msg.poweruptype == 'punch':
 798                tex = PowerupBoxFactory.get().tex_punch
 799                self._flash_billboard(tex)
 800                self.equip_boxing_gloves()
 801                if self.powerups_expire and not self.default_boxing_gloves:
 802                    self.node.boxing_gloves_flashing = False
 803                    self.node.mini_billboard_3_texture = tex
 804                    t_ms = int(bs.time() * 1000.0)
 805                    assert isinstance(t_ms, int)
 806                    self.node.mini_billboard_3_start_time = t_ms
 807                    self.node.mini_billboard_3_end_time = (
 808                        t_ms + POWERUP_WEAR_OFF_TIME
 809                    )
 810                    self._boxing_gloves_wear_off_flash_timer = bs.Timer(
 811                        (POWERUP_WEAR_OFF_TIME - 2000) / 1000.0,
 812                        bs.WeakCall(self._gloves_wear_off_flash),
 813                    )
 814                    self._boxing_gloves_wear_off_timer = bs.Timer(
 815                        POWERUP_WEAR_OFF_TIME / 1000.0,
 816                        bs.WeakCall(self._gloves_wear_off),
 817                    )
 818            elif msg.poweruptype == 'shield':
 819                factory = SpazFactory.get()
 820
 821                # Let's allow powerup-equipped shields to lose hp over time.
 822                self.equip_shields(decay=factory.shield_decay_rate > 0)
 823            elif msg.poweruptype == 'curse':
 824                self.curse()
 825            elif msg.poweruptype == 'ice_bombs':
 826                self.bomb_type = 'ice'
 827                tex = self._get_bomb_type_tex()
 828                self._flash_billboard(tex)
 829                if self.powerups_expire:
 830                    self.node.mini_billboard_2_texture = tex
 831                    t_ms = int(bs.time() * 1000.0)
 832                    assert isinstance(t_ms, int)
 833                    self.node.mini_billboard_2_start_time = t_ms
 834                    self.node.mini_billboard_2_end_time = (
 835                        t_ms + POWERUP_WEAR_OFF_TIME
 836                    )
 837                    self._bomb_wear_off_flash_timer = bs.Timer(
 838                        (POWERUP_WEAR_OFF_TIME - 2000) / 1000.0,
 839                        bs.WeakCall(self._bomb_wear_off_flash),
 840                    )
 841                    self._bomb_wear_off_timer = bs.Timer(
 842                        POWERUP_WEAR_OFF_TIME / 1000.0,
 843                        bs.WeakCall(self._bomb_wear_off),
 844                    )
 845            elif msg.poweruptype == 'health':
 846                if self._cursed:
 847                    self._cursed = False
 848
 849                    # Remove cursed material.
 850                    factory = SpazFactory.get()
 851                    for attr in ['materials', 'roller_materials']:
 852                        materials = getattr(self.node, attr)
 853                        if factory.curse_material in materials:
 854                            setattr(
 855                                self.node,
 856                                attr,
 857                                tuple(
 858                                    m
 859                                    for m in materials
 860                                    if m != factory.curse_material
 861                                ),
 862                            )
 863                    self.node.curse_death_time = 0
 864                self.hitpoints = self.hitpoints_max
 865                self._flash_billboard(PowerupBoxFactory.get().tex_health)
 866                self.node.hurt = 0
 867                self._last_hit_time = None
 868                self._num_times_hit = 0
 869
 870            self.node.handlemessage('flash')
 871            if msg.sourcenode:
 872                msg.sourcenode.handlemessage(bs.PowerupAcceptMessage())
 873            return True
 874
 875        elif isinstance(msg, bs.FreezeMessage):
 876            if not self.node:
 877                return None
 878            if self.node.invincible:
 879                SpazFactory.get().block_sound.play(
 880                    1.0,
 881                    position=self.node.position,
 882                )
 883                return None
 884            if self.shield:
 885                return None
 886            if not self.frozen:
 887                self.frozen = True
 888                self.node.frozen = True
 889                bs.timer(5.0, bs.WeakCall(self.handlemessage, bs.ThawMessage()))
 890                # Instantly shatter if we're already dead.
 891                # (otherwise its hard to tell we're dead).
 892                if self.hitpoints <= 0:
 893                    self.shatter()
 894
 895        elif isinstance(msg, bs.ThawMessage):
 896            if self.frozen and not self.shattered and self.node:
 897                self.frozen = False
 898                self.node.frozen = False
 899
 900        elif isinstance(msg, bs.HitMessage):
 901            if not self.node:
 902                return None
 903            if self.node.invincible:
 904                SpazFactory.get().block_sound.play(
 905                    1.0,
 906                    position=self.node.position,
 907                )
 908                return True
 909
 910            # If we were recently hit, don't count this as another.
 911            # (so punch flurries and bomb pileups essentially count as 1 hit).
 912            local_time = int(bs.time() * 1000.0)
 913            assert isinstance(local_time, int)
 914            if (
 915                self._last_hit_time is None
 916                or local_time - self._last_hit_time > 1000
 917            ):
 918                self._num_times_hit += 1
 919                self._last_hit_time = local_time
 920
 921            mag = msg.magnitude * self.impact_scale
 922            velocity_mag = msg.velocity_magnitude * self.impact_scale
 923            damage_scale = 0.22
 924
 925            # If they've got a shield, deliver it to that instead.
 926            if self.shield:
 927                if msg.flat_damage:
 928                    damage = msg.flat_damage * self.impact_scale
 929                else:
 930                    # Hit our spaz with an impulse but tell it to only return
 931                    # theoretical damage; not apply the impulse.
 932                    assert msg.force_direction is not None
 933                    self.node.handlemessage(
 934                        'impulse',
 935                        msg.pos[0],
 936                        msg.pos[1],
 937                        msg.pos[2],
 938                        msg.velocity[0],
 939                        msg.velocity[1],
 940                        msg.velocity[2],
 941                        mag,
 942                        velocity_mag,
 943                        msg.radius,
 944                        1,
 945                        msg.force_direction[0],
 946                        msg.force_direction[1],
 947                        msg.force_direction[2],
 948                    )
 949                    damage = damage_scale * self.node.damage
 950
 951                assert self.shield_hitpoints is not None
 952                self.shield_hitpoints -= int(damage)
 953                self.shield.hurt = (
 954                    1.0
 955                    - float(self.shield_hitpoints) / self.shield_hitpoints_max
 956                )
 957
 958                # Its a cleaner event if a hit just kills the shield
 959                # without damaging the player.
 960                # However, massive damage events should still be able to
 961                # damage the player. This hopefully gives us a happy medium.
 962                max_spillover = SpazFactory.get().max_shield_spillover_damage
 963                if self.shield_hitpoints <= 0:
 964                    # FIXME: Transition out perhaps?
 965                    self.shield.delete()
 966                    self.shield = None
 967                    SpazFactory.get().shield_down_sound.play(
 968                        1.0,
 969                        position=self.node.position,
 970                    )
 971
 972                    # Emit some cool looking sparks when the shield dies.
 973                    npos = self.node.position
 974                    bs.emitfx(
 975                        position=(npos[0], npos[1] + 0.9, npos[2]),
 976                        velocity=self.node.velocity,
 977                        count=random.randrange(20, 30),
 978                        scale=1.0,
 979                        spread=0.6,
 980                        chunk_type='spark',
 981                    )
 982
 983                else:
 984                    SpazFactory.get().shield_hit_sound.play(
 985                        0.5,
 986                        position=self.node.position,
 987                    )
 988
 989                # Emit some cool looking sparks on shield hit.
 990                assert msg.force_direction is not None
 991                bs.emitfx(
 992                    position=msg.pos,
 993                    velocity=(
 994                        msg.force_direction[0] * 1.0,
 995                        msg.force_direction[1] * 1.0,
 996                        msg.force_direction[2] * 1.0,
 997                    ),
 998                    count=min(30, 5 + int(damage * 0.005)),
 999                    scale=0.5,
1000                    spread=0.3,
1001                    chunk_type='spark',
1002                )
1003
1004                # If they passed our spillover threshold,
1005                # pass damage along to spaz.
1006                if self.shield_hitpoints <= -max_spillover:
1007                    leftover_damage = -max_spillover - self.shield_hitpoints
1008                    shield_leftover_ratio = leftover_damage / damage
1009
1010                    # Scale down the magnitudes applied to spaz accordingly.
1011                    mag *= shield_leftover_ratio
1012                    velocity_mag *= shield_leftover_ratio
1013                else:
1014                    return True  # Good job shield!
1015            else:
1016                shield_leftover_ratio = 1.0
1017
1018            if msg.flat_damage:
1019                damage = int(
1020                    msg.flat_damage * self.impact_scale * shield_leftover_ratio
1021                )
1022            else:
1023                # Hit it with an impulse and get the resulting damage.
1024                assert msg.force_direction is not None
1025                self.node.handlemessage(
1026                    'impulse',
1027                    msg.pos[0],
1028                    msg.pos[1],
1029                    msg.pos[2],
1030                    msg.velocity[0],
1031                    msg.velocity[1],
1032                    msg.velocity[2],
1033                    mag,
1034                    velocity_mag,
1035                    msg.radius,
1036                    0,
1037                    msg.force_direction[0],
1038                    msg.force_direction[1],
1039                    msg.force_direction[2],
1040                )
1041
1042                damage = int(damage_scale * self.node.damage)
1043            self.node.handlemessage('hurt_sound')
1044
1045            # Play punch impact sound based on damage if it was a punch.
1046            if msg.hit_type == 'punch':
1047                self.on_punched(damage)
1048
1049                # If damage was significant, lets show it.
1050                if damage >= 350:
1051                    assert msg.force_direction is not None
1052                    bs.show_damage_count(
1053                        '-' + str(int(damage / 10)) + '%',
1054                        msg.pos,
1055                        msg.force_direction,
1056                    )
1057
1058                # Let's always add in a super-punch sound with boxing
1059                # gloves just to differentiate them.
1060                if msg.hit_subtype == 'super_punch':
1061                    SpazFactory.get().punch_sound_stronger.play(
1062                        1.0,
1063                        position=self.node.position,
1064                    )
1065                if damage >= 500:
1066                    sounds = SpazFactory.get().punch_sound_strong
1067                    sound = sounds[random.randrange(len(sounds))]
1068                elif damage >= 100:
1069                    sound = SpazFactory.get().punch_sound
1070                else:
1071                    sound = SpazFactory.get().punch_sound_weak
1072                sound.play(1.0, position=self.node.position)
1073
1074                # Throw up some chunks.
1075                assert msg.force_direction is not None
1076                bs.emitfx(
1077                    position=msg.pos,
1078                    velocity=(
1079                        msg.force_direction[0] * 0.5,
1080                        msg.force_direction[1] * 0.5,
1081                        msg.force_direction[2] * 0.5,
1082                    ),
1083                    count=min(10, 1 + int(damage * 0.0025)),
1084                    scale=0.3,
1085                    spread=0.03,
1086                )
1087
1088                bs.emitfx(
1089                    position=msg.pos,
1090                    chunk_type='sweat',
1091                    velocity=(
1092                        msg.force_direction[0] * 1.3,
1093                        msg.force_direction[1] * 1.3 + 5.0,
1094                        msg.force_direction[2] * 1.3,
1095                    ),
1096                    count=min(30, 1 + int(damage * 0.04)),
1097                    scale=0.9,
1098                    spread=0.28,
1099                )
1100
1101                # Momentary flash.
1102                hurtiness = damage * 0.003
1103                punchpos = (
1104                    msg.pos[0] + msg.force_direction[0] * 0.02,
1105                    msg.pos[1] + msg.force_direction[1] * 0.02,
1106                    msg.pos[2] + msg.force_direction[2] * 0.02,
1107                )
1108                flash_color = (1.0, 0.8, 0.4)
1109                light = bs.newnode(
1110                    'light',
1111                    attrs={
1112                        'position': punchpos,
1113                        'radius': 0.12 + hurtiness * 0.12,
1114                        'intensity': 0.3 * (1.0 + 1.0 * hurtiness),
1115                        'height_attenuated': False,
1116                        'color': flash_color,
1117                    },
1118                )
1119                bs.timer(0.06, light.delete)
1120
1121                flash = bs.newnode(
1122                    'flash',
1123                    attrs={
1124                        'position': punchpos,
1125                        'size': 0.17 + 0.17 * hurtiness,
1126                        'color': flash_color,
1127                    },
1128                )
1129                bs.timer(0.06, flash.delete)
1130
1131            if msg.hit_type == 'impact':
1132                assert msg.force_direction is not None
1133                bs.emitfx(
1134                    position=msg.pos,
1135                    velocity=(
1136                        msg.force_direction[0] * 2.0,
1137                        msg.force_direction[1] * 2.0,
1138                        msg.force_direction[2] * 2.0,
1139                    ),
1140                    count=min(10, 1 + int(damage * 0.01)),
1141                    scale=0.4,
1142                    spread=0.1,
1143                )
1144            if self.hitpoints > 0:
1145                # It's kinda crappy to die from impacts, so lets reduce
1146                # impact damage by a reasonable amount *if* it'll keep us alive.
1147                if msg.hit_type == 'impact' and damage >= self.hitpoints:
1148                    # Drop damage to whatever puts us at 10 hit points,
1149                    # or 200 less than it used to be whichever is greater
1150                    # (so it *can* still kill us if its high enough).
1151                    newdamage = max(damage - 200, self.hitpoints - 10)
1152                    damage = newdamage
1153                self.node.handlemessage('flash')
1154
1155                # If we're holding something, drop it.
1156                if damage > 0.0 and self.node.hold_node:
1157                    self.node.hold_node = None
1158                self.hitpoints -= damage
1159                self.node.hurt = (
1160                    1.0 - float(self.hitpoints) / self.hitpoints_max
1161                )
1162
1163                # If we're cursed, *any* damage blows us up.
1164                if self._cursed and damage > 0:
1165                    bs.timer(
1166                        0.05,
1167                        bs.WeakCall(
1168                            self.curse_explode, msg.get_source_player(bs.Player)
1169                        ),
1170                    )
1171
1172                # If we're frozen, shatter.. otherwise die if we hit zero
1173                if self.frozen and (damage > 200 or self.hitpoints <= 0):
1174                    self.shatter()
1175                elif self.hitpoints <= 0:
1176                    self.node.handlemessage(
1177                        bs.DieMessage(how=bs.DeathType.IMPACT)
1178                    )
1179
1180            # If we're dead, take a look at the smoothed damage value
1181            # (which gives us a smoothed average of recent damage) and shatter
1182            # us if its grown high enough.
1183            if self.hitpoints <= 0:
1184                damage_avg = self.node.damage_smoothed * damage_scale
1185                if damage_avg >= 1000:
1186                    self.shatter()
1187
1188        elif isinstance(msg, BombDiedMessage):
1189            self.bomb_count += 1
1190
1191        elif isinstance(msg, bs.DieMessage):
1192            wasdead = self._dead
1193            self._dead = True
1194            self.hitpoints = 0
1195            if msg.immediate:
1196                if self.node:
1197                    self.node.delete()
1198            elif self.node:
1199                if not wasdead:
1200                    self.node.hurt = 1.0
1201                    if self.play_big_death_sound:
1202                        SpazFactory.get().single_player_death_sound.play()
1203                    self.node.dead = True
1204                    bs.timer(2.0, self.node.delete)
1205
1206        elif isinstance(msg, bs.OutOfBoundsMessage):
1207            # By default we just die here.
1208            self.handlemessage(bs.DieMessage(how=bs.DeathType.FALL))
1209
1210        elif isinstance(msg, bs.StandMessage):
1211            self._last_stand_pos = (
1212                msg.position[0],
1213                msg.position[1],
1214                msg.position[2],
1215            )
1216            if self.node:
1217                self.node.handlemessage(
1218                    'stand',
1219                    msg.position[0],
1220                    msg.position[1],
1221                    msg.position[2],
1222                    msg.angle,
1223                )
1224
1225        elif isinstance(msg, CurseExplodeMessage):
1226            self.curse_explode()
1227
1228        elif isinstance(msg, PunchHitMessage):
1229            if not self.node:
1230                return None
1231            node = bs.getcollision().opposingnode
1232
1233            # Don't want to physically affect powerups.
1234            if node.getdelegate(PowerupBox):
1235                return None
1236
1237            # Only allow one hit per node per punch.
1238            if node and (node not in self._punched_nodes):
1239                punch_momentum_angular = (
1240                    self.node.punch_momentum_angular * self._punch_power_scale
1241                )
1242                punch_power = self.node.punch_power * self._punch_power_scale
1243
1244                # Ok here's the deal:  we pass along our base velocity for use
1245                # in the impulse damage calculations since that is a more
1246                # predictable value than our fist velocity, which is rather
1247                # erratic. However, we want to actually apply force in the
1248                # direction our fist is moving so it looks better. So we still
1249                # pass that along as a direction. Perhaps a time-averaged
1250                # fist-velocity would work too?.. perhaps should try that.
1251
1252                # If its something besides another spaz, just do a muffled
1253                # punch sound.
1254                if node.getnodetype() != 'spaz':
1255                    sounds = SpazFactory.get().impact_sounds_medium
1256                    sound = sounds[random.randrange(len(sounds))]
1257                    sound.play(1.0, position=self.node.position)
1258
1259                ppos = self.node.punch_position
1260                punchdir = self.node.punch_velocity
1261                vel = self.node.punch_momentum_linear
1262
1263                self._punched_nodes.add(node)
1264                node.handlemessage(
1265                    bs.HitMessage(
1266                        pos=ppos,
1267                        velocity=vel,
1268                        magnitude=punch_power * punch_momentum_angular * 110.0,
1269                        velocity_magnitude=punch_power * 40,
1270                        radius=0,
1271                        srcnode=self.node,
1272                        source_player=self.source_player,
1273                        force_direction=punchdir,
1274                        hit_type='punch',
1275                        hit_subtype=(
1276                            'super_punch'
1277                            if self._has_boxing_gloves
1278                            else 'default'
1279                        ),
1280                    )
1281                )
1282
1283                # Also apply opposite to ourself for the first punch only.
1284                # This is given as a constant force so that it is more
1285                # noticeable for slower punches where it matters. For fast
1286                # awesome looking punches its ok if we punch 'through'
1287                # the target.
1288                mag = -400.0
1289                if self._hockey:
1290                    mag *= 0.5
1291                if len(self._punched_nodes) == 1:
1292                    self.node.handlemessage(
1293                        'kick_back',
1294                        ppos[0],
1295                        ppos[1],
1296                        ppos[2],
1297                        punchdir[0],
1298                        punchdir[1],
1299                        punchdir[2],
1300                        mag,
1301                    )
1302        elif isinstance(msg, PickupMessage):
1303            if not self.node:
1304                return None
1305
1306            try:
1307                collision = bs.getcollision()
1308                opposingnode = collision.opposingnode
1309                opposingbody = collision.opposingbody
1310            except bs.NotFoundError:
1311                return True
1312
1313            # Don't allow picking up of invincible dudes.
1314            try:
1315                if opposingnode.invincible:
1316                    return True
1317            except Exception:
1318                pass
1319
1320            # If we're grabbing the pelvis of a non-shattered spaz, we wanna
1321            # grab the torso instead.
1322            if (
1323                opposingnode.getnodetype() == 'spaz'
1324                and not opposingnode.shattered
1325                and opposingbody == 4
1326            ):
1327                opposingbody = 1
1328
1329            # Special case - if we're holding a flag, don't replace it
1330            # (hmm - should make this customizable or more low level).
1331            held = self.node.hold_node
1332            if held and held.getnodetype() == 'flag':
1333                return True
1334
1335            # Note: hold_body needs to be set before hold_node.
1336            self.node.hold_body = opposingbody
1337            self.node.hold_node = opposingnode
1338        elif isinstance(msg, bs.CelebrateMessage):
1339            if self.node:
1340                self.node.handlemessage('celebrate', int(msg.duration * 1000))
1341
1342        else:
1343            return super().handlemessage(msg)
1344        return None
1345
1346    def drop_bomb(self) -> Bomb | None:
1347        """
1348        Tell the spaz to drop one of his bombs, and returns
1349        the resulting bomb object.
1350        If the spaz has no bombs or is otherwise unable to
1351        drop a bomb, returns None.
1352        """
1353
1354        if (self.land_mine_count <= 0 and self.bomb_count <= 0) or self.frozen:
1355            return None
1356        assert self.node
1357        pos = self.node.position_forward
1358        vel = self.node.velocity
1359
1360        if self.land_mine_count > 0:
1361            dropping_bomb = False
1362            self.set_land_mine_count(self.land_mine_count - 1)
1363            bomb_type = 'land_mine'
1364        else:
1365            dropping_bomb = True
1366            bomb_type = self.bomb_type
1367
1368        bomb = Bomb(
1369            position=(pos[0], pos[1] - 0.0, pos[2]),
1370            velocity=(vel[0], vel[1], vel[2]),
1371            bomb_type=bomb_type,
1372            blast_radius=self.blast_radius,
1373            source_player=self.source_player,
1374            owner=self.node,
1375        ).autoretain()
1376
1377        assert bomb.node
1378        if dropping_bomb:
1379            self.bomb_count -= 1
1380            bomb.node.add_death_action(
1381                bs.WeakCall(self.handlemessage, BombDiedMessage())
1382            )
1383        self._pick_up(bomb.node)
1384
1385        for clb in self._dropped_bomb_callbacks:
1386            clb(self, bomb)
1387
1388        return bomb
1389
1390    def _pick_up(self, node: bs.Node) -> None:
1391        if self.node:
1392            # Note: hold_body needs to be set before hold_node.
1393            self.node.hold_body = 0
1394            self.node.hold_node = node
1395
1396    def set_land_mine_count(self, count: int) -> None:
1397        """Set the number of land-mines this spaz is carrying."""
1398        self.land_mine_count = count
1399        if self.node:
1400            if self.land_mine_count != 0:
1401                self.node.counter_text = 'x' + str(self.land_mine_count)
1402                self.node.counter_texture = (
1403                    PowerupBoxFactory.get().tex_land_mines
1404                )
1405            else:
1406                self.node.counter_text = ''
1407
1408    def curse_explode(self, source_player: bs.Player | None = None) -> None:
1409        """Explode the poor spaz spectacularly."""
1410        if self._cursed and self.node:
1411            self.shatter(extreme=True)
1412            self.handlemessage(bs.DieMessage())
1413            activity = self._activity()
1414            if activity:
1415                Blast(
1416                    position=self.node.position,
1417                    velocity=self.node.velocity,
1418                    blast_radius=3.0,
1419                    blast_type='normal',
1420                    source_player=(
1421                        source_player if source_player else self.source_player
1422                    ),
1423                ).autoretain()
1424            self._cursed = False
1425
1426    def shatter(self, extreme: bool = False) -> None:
1427        """Break the poor spaz into little bits."""
1428        if self.shattered:
1429            return
1430        self.shattered = True
1431        assert self.node
1432        if self.frozen:
1433            # Momentary flash of light.
1434            light = bs.newnode(
1435                'light',
1436                attrs={
1437                    'position': self.node.position,
1438                    'radius': 0.5,
1439                    'height_attenuated': False,
1440                    'color': (0.8, 0.8, 1.0),
1441                },
1442            )
1443
1444            bs.animate(
1445                light, 'intensity', {0.0: 3.0, 0.04: 0.5, 0.08: 0.07, 0.3: 0}
1446            )
1447            bs.timer(0.3, light.delete)
1448
1449            # Emit ice chunks.
1450            bs.emitfx(
1451                position=self.node.position,
1452                velocity=self.node.velocity,
1453                count=int(random.random() * 10.0 + 10.0),
1454                scale=0.6,
1455                spread=0.2,
1456                chunk_type='ice',
1457            )
1458            bs.emitfx(
1459                position=self.node.position,
1460                velocity=self.node.velocity,
1461                count=int(random.random() * 10.0 + 10.0),
1462                scale=0.3,
1463                spread=0.2,
1464                chunk_type='ice',
1465            )
1466            SpazFactory.get().shatter_sound.play(
1467                1.0,
1468                position=self.node.position,
1469            )
1470        else:
1471            SpazFactory.get().splatter_sound.play(
1472                1.0,
1473                position=self.node.position,
1474            )
1475        self.handlemessage(bs.DieMessage())
1476        self.node.shattered = 2 if extreme else 1
1477
1478    def _hit_self(self, intensity: float) -> None:
1479        if not self.node:
1480            return
1481        pos = self.node.position
1482        self.handlemessage(
1483            bs.HitMessage(
1484                flat_damage=50.0 * intensity,
1485                pos=pos,
1486                force_direction=self.node.velocity,
1487                hit_type='impact',
1488            )
1489        )
1490        self.node.handlemessage('knockout', max(0.0, 50.0 * intensity))
1491        sounds: Sequence[bs.Sound]
1492        if intensity >= 5.0:
1493            sounds = SpazFactory.get().impact_sounds_harder
1494        elif intensity >= 3.0:
1495            sounds = SpazFactory.get().impact_sounds_hard
1496        else:
1497            sounds = SpazFactory.get().impact_sounds_medium
1498        sound = sounds[random.randrange(len(sounds))]
1499        sound.play(position=pos, volume=5.0)
1500
1501    def _get_bomb_type_tex(self) -> bs.Texture:
1502        factory = PowerupBoxFactory.get()
1503        if self.bomb_type == 'sticky':
1504            return factory.tex_sticky_bombs
1505        if self.bomb_type == 'ice':
1506            return factory.tex_ice_bombs
1507        if self.bomb_type == 'impact':
1508            return factory.tex_impact_bombs
1509        raise ValueError('invalid bomb type')
1510
1511    def _flash_billboard(self, tex: bs.Texture) -> None:
1512        assert self.node
1513        self.node.billboard_texture = tex
1514        self.node.billboard_cross_out = False
1515        bs.animate(
1516            self.node,
1517            'billboard_opacity',
1518            {0.0: 0.0, 0.1: 1.0, 0.4: 1.0, 0.5: 0.0},
1519        )
1520
1521    def set_bomb_count(self, count: int) -> None:
1522        """Sets the number of bombs this Spaz has."""
1523        # We can't just set bomb_count because some bombs may be laid currently
1524        # so we have to do a relative diff based on max.
1525        diff = count - self._max_bomb_count
1526        self._max_bomb_count += diff
1527        self.bomb_count += diff
1528
1529    def _gloves_wear_off_flash(self) -> None:
1530        if self.node:
1531            self.node.boxing_gloves_flashing = True
1532            self.node.billboard_texture = PowerupBoxFactory.get().tex_punch
1533            self.node.billboard_opacity = 1.0
1534            self.node.billboard_cross_out = True
1535
1536    def _gloves_wear_off(self) -> None:
1537        if self._demo_mode:  # Preserve old behavior.
1538            self._punch_power_scale = 1.2
1539            self._punch_cooldown = BASE_PUNCH_COOLDOWN
1540        else:
1541            factory = SpazFactory.get()
1542            self._punch_power_scale = factory.punch_power_scale
1543            self._punch_cooldown = factory.punch_cooldown
1544        self._has_boxing_gloves = False
1545        if self.node:
1546            PowerupBoxFactory.get().powerdown_sound.play(
1547                position=self.node.position,
1548            )
1549            self.node.boxing_gloves = False
1550            self.node.billboard_opacity = 0.0
1551
1552    def _multi_bomb_wear_off_flash(self) -> None:
1553        if self.node:
1554            self.node.billboard_texture = PowerupBoxFactory.get().tex_bomb
1555            self.node.billboard_opacity = 1.0
1556            self.node.billboard_cross_out = True
1557
1558    def _multi_bomb_wear_off(self) -> None:
1559        self.set_bomb_count(self.default_bomb_count)
1560        if self.node:
1561            PowerupBoxFactory.get().powerdown_sound.play(
1562                position=self.node.position,
1563            )
1564            self.node.billboard_opacity = 0.0
1565
1566    def _bomb_wear_off_flash(self) -> None:
1567        if self.node:
1568            self.node.billboard_texture = self._get_bomb_type_tex()
1569            self.node.billboard_opacity = 1.0
1570            self.node.billboard_cross_out = True
1571
1572    def _bomb_wear_off(self) -> None:
1573        self.bomb_type = self.bomb_type_default
1574        if self.node:
1575            PowerupBoxFactory.get().powerdown_sound.play(
1576                position=self.node.position,
1577            )
1578            self.node.billboard_opacity = 0.0