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