bascenev1lib.actor.bomb

   1# Released under the MIT License. See LICENSE for details.
   2#
   3"""Various classes for bombs, mines, tnt, etc."""
   4
   5# FIXME
   6# pylint: disable=too-many-lines
   7
   8from __future__ import annotations
   9
  10import random
  11from typing import TYPE_CHECKING, TypeVar, override
  12
  13import bascenev1 as bs
  14
  15from bascenev1lib.gameutils import SharedObjects
  16
  17if TYPE_CHECKING:
  18    from typing import Any, Sequence, Callable
  19
  20PlayerT = TypeVar('PlayerT', bound='bs.Player')
  21
  22
  23class BombFactory:
  24    """Wraps up media and other resources used by bs.Bombs.
  25
  26    Category: **Gameplay Classes**
  27
  28    A single instance of this is shared between all bombs
  29    and can be retrieved via bascenev1lib.actor.bomb.get_factory().
  30    """
  31
  32    bomb_mesh: bs.Mesh
  33    """The bs.Mesh of a standard or ice bomb."""
  34
  35    sticky_bomb_mesh: bs.Mesh
  36    """The bs.Mesh of a sticky-bomb."""
  37
  38    impact_bomb_mesh: bs.Mesh
  39    """The bs.Mesh of an impact-bomb."""
  40
  41    land_mine_mesh: bs.Mesh
  42    """The bs.Mesh of a land-mine."""
  43
  44    tnt_mesh: bs.Mesh
  45    """The bs.Mesh of a tnt box."""
  46
  47    regular_tex: bs.Texture
  48    """The bs.Texture for regular bombs."""
  49
  50    ice_tex: bs.Texture
  51    """The bs.Texture for ice bombs."""
  52
  53    sticky_tex: bs.Texture
  54    """The bs.Texture for sticky bombs."""
  55
  56    impact_tex: bs.Texture
  57    """The bs.Texture for impact bombs."""
  58
  59    impact_lit_tex: bs.Texture
  60    """The bs.Texture for impact bombs with lights lit."""
  61
  62    land_mine_tex: bs.Texture
  63    """The bs.Texture for land-mines."""
  64
  65    land_mine_lit_tex: bs.Texture
  66    """The bs.Texture for land-mines with the light lit."""
  67
  68    tnt_tex: bs.Texture
  69    """The bs.Texture for tnt boxes."""
  70
  71    hiss_sound: bs.Sound
  72    """The bs.Sound for the hiss sound an ice bomb makes."""
  73
  74    debris_fall_sound: bs.Sound
  75    """The bs.Sound for random falling debris after an explosion."""
  76
  77    wood_debris_fall_sound: bs.Sound
  78    """A bs.Sound for random wood debris falling after an explosion."""
  79
  80    explode_sounds: Sequence[bs.Sound]
  81    """A tuple of bs.Sound-s for explosions."""
  82
  83    freeze_sound: bs.Sound
  84    """A bs.Sound of an ice bomb freezing something."""
  85
  86    fuse_sound: bs.Sound
  87    """A bs.Sound of a burning fuse."""
  88
  89    activate_sound: bs.Sound
  90    """A bs.Sound for an activating impact bomb."""
  91
  92    warn_sound: bs.Sound
  93    """A bs.Sound for an impact bomb about to explode due to time-out."""
  94
  95    bomb_material: bs.Material
  96    """A bs.Material applied to all bombs."""
  97
  98    normal_sound_material: bs.Material
  99    """A bs.Material that generates standard bomb noises on impacts, etc."""
 100
 101    sticky_material: bs.Material
 102    """A bs.Material that makes 'splat' sounds and makes collisions softer."""
 103
 104    land_mine_no_explode_material: bs.Material
 105    """A bs.Material that keeps land-mines from blowing up.
 106       Applied to land-mines when they are created to allow land-mines to
 107       touch without exploding."""
 108
 109    land_mine_blast_material: bs.Material
 110    """A bs.Material applied to activated land-mines that causes them to
 111       explode on impact."""
 112
 113    impact_blast_material: bs.Material
 114    """A bs.Material applied to activated impact-bombs that causes them to
 115       explode on impact."""
 116
 117    blast_material: bs.Material
 118    """A bs.Material applied to bomb blast geometry which triggers impact
 119       events with what it touches."""
 120
 121    dink_sounds: Sequence[bs.Sound]
 122    """A tuple of bs.Sound-s for when bombs hit the ground."""
 123
 124    sticky_impact_sound: bs.Sound
 125    """The bs.Sound for a squish made by a sticky bomb hitting something."""
 126
 127    roll_sound: bs.Sound
 128    """bs.Sound for a rolling bomb."""
 129
 130    _STORENAME = bs.storagename()
 131
 132    @classmethod
 133    def get(cls) -> BombFactory:
 134        """Get/create a shared bascenev1lib.actor.bomb.BombFactory object."""
 135        activity = bs.getactivity()
 136        factory = activity.customdata.get(cls._STORENAME)
 137        if factory is None:
 138            factory = BombFactory()
 139            activity.customdata[cls._STORENAME] = factory
 140        assert isinstance(factory, BombFactory)
 141        return factory
 142
 143    def random_explode_sound(self) -> bs.Sound:
 144        """Return a random explosion bs.Sound from the factory."""
 145        return self.explode_sounds[random.randrange(len(self.explode_sounds))]
 146
 147    def __init__(self) -> None:
 148        """Instantiate a BombFactory.
 149
 150        You shouldn't need to do this; call
 151        bascenev1lib.actor.bomb.get_factory() to get a shared instance.
 152        """
 153        shared = SharedObjects.get()
 154
 155        self.bomb_mesh = bs.getmesh('bomb')
 156        self.sticky_bomb_mesh = bs.getmesh('bombSticky')
 157        self.impact_bomb_mesh = bs.getmesh('impactBomb')
 158        self.land_mine_mesh = bs.getmesh('landMine')
 159        self.tnt_mesh = bs.getmesh('tnt')
 160
 161        self.regular_tex = bs.gettexture('bombColor')
 162        self.ice_tex = bs.gettexture('bombColorIce')
 163        self.sticky_tex = bs.gettexture('bombStickyColor')
 164        self.impact_tex = bs.gettexture('impactBombColor')
 165        self.impact_lit_tex = bs.gettexture('impactBombColorLit')
 166        self.land_mine_tex = bs.gettexture('landMine')
 167        self.land_mine_lit_tex = bs.gettexture('landMineLit')
 168        self.tnt_tex = bs.gettexture('tnt')
 169
 170        self.hiss_sound = bs.getsound('hiss')
 171        self.debris_fall_sound = bs.getsound('debrisFall')
 172        self.wood_debris_fall_sound = bs.getsound('woodDebrisFall')
 173
 174        self.explode_sounds = (
 175            bs.getsound('explosion01'),
 176            bs.getsound('explosion02'),
 177            bs.getsound('explosion03'),
 178            bs.getsound('explosion04'),
 179            bs.getsound('explosion05'),
 180        )
 181
 182        self.freeze_sound = bs.getsound('freeze')
 183        self.fuse_sound = bs.getsound('fuse01')
 184        self.activate_sound = bs.getsound('activateBeep')
 185        self.warn_sound = bs.getsound('warnBeep')
 186
 187        # Set up our material so new bombs don't collide with objects
 188        # that they are initially overlapping.
 189        self.bomb_material = bs.Material()
 190        self.normal_sound_material = bs.Material()
 191        self.sticky_material = bs.Material()
 192
 193        self.bomb_material.add_actions(
 194            conditions=(
 195                (
 196                    ('we_are_younger_than', 100),
 197                    'or',
 198                    ('they_are_younger_than', 100),
 199                ),
 200                'and',
 201                ('they_have_material', shared.object_material),
 202            ),
 203            actions=('modify_node_collision', 'collide', False),
 204        )
 205
 206        # We want pickup materials to always hit us even if we're currently
 207        # not colliding with their node. (generally due to the above rule)
 208        self.bomb_material.add_actions(
 209            conditions=('they_have_material', shared.pickup_material),
 210            actions=('modify_part_collision', 'use_node_collide', False),
 211        )
 212
 213        self.bomb_material.add_actions(
 214            actions=('modify_part_collision', 'friction', 0.3)
 215        )
 216
 217        self.land_mine_no_explode_material = bs.Material()
 218        self.land_mine_blast_material = bs.Material()
 219        self.land_mine_blast_material.add_actions(
 220            conditions=(
 221                ('we_are_older_than', 200),
 222                'and',
 223                ('they_are_older_than', 200),
 224                'and',
 225                ('eval_colliding',),
 226                'and',
 227                (
 228                    (
 229                        'they_dont_have_material',
 230                        self.land_mine_no_explode_material,
 231                    ),
 232                    'and',
 233                    (
 234                        ('they_have_material', shared.object_material),
 235                        'or',
 236                        ('they_have_material', shared.player_material),
 237                    ),
 238                ),
 239            ),
 240            actions=('message', 'our_node', 'at_connect', ImpactMessage()),
 241        )
 242
 243        self.impact_blast_material = bs.Material()
 244        self.impact_blast_material.add_actions(
 245            conditions=(
 246                ('we_are_older_than', 200),
 247                'and',
 248                ('they_are_older_than', 200),
 249                'and',
 250                ('eval_colliding',),
 251                'and',
 252                (
 253                    ('they_have_material', shared.footing_material),
 254                    'or',
 255                    ('they_have_material', shared.object_material),
 256                ),
 257            ),
 258            actions=('message', 'our_node', 'at_connect', ImpactMessage()),
 259        )
 260
 261        self.blast_material = bs.Material()
 262        self.blast_material.add_actions(
 263            conditions=('they_have_material', shared.object_material),
 264            actions=(
 265                ('modify_part_collision', 'collide', True),
 266                ('modify_part_collision', 'physical', False),
 267                ('message', 'our_node', 'at_connect', ExplodeHitMessage()),
 268            ),
 269        )
 270
 271        self.dink_sounds = (
 272            bs.getsound('bombDrop01'),
 273            bs.getsound('bombDrop02'),
 274        )
 275        self.sticky_impact_sound = bs.getsound('stickyImpact')
 276        self.roll_sound = bs.getsound('bombRoll01')
 277
 278        # Collision sounds.
 279        self.normal_sound_material.add_actions(
 280            conditions=('they_have_material', shared.footing_material),
 281            actions=(
 282                ('impact_sound', self.dink_sounds, 2, 0.8),
 283                ('roll_sound', self.roll_sound, 3, 6),
 284            ),
 285        )
 286
 287        self.sticky_material.add_actions(
 288            actions=(
 289                ('modify_part_collision', 'stiffness', 0.1),
 290                ('modify_part_collision', 'damping', 1.0),
 291            )
 292        )
 293
 294        self.sticky_material.add_actions(
 295            conditions=(
 296                ('they_have_material', shared.player_material),
 297                'or',
 298                ('they_have_material', shared.footing_material),
 299            ),
 300            actions=('message', 'our_node', 'at_connect', SplatMessage()),
 301        )
 302
 303
 304class SplatMessage:
 305    """Tells an object to make a splat noise."""
 306
 307
 308class ExplodeMessage:
 309    """Tells an object to explode."""
 310
 311
 312class ImpactMessage:
 313    """Tell an object it touched something."""
 314
 315
 316class ArmMessage:
 317    """Tell an object to become armed."""
 318
 319
 320class WarnMessage:
 321    """Tell an object to issue a warning sound."""
 322
 323
 324class ExplodeHitMessage:
 325    """Tell an object it was hit by an explosion."""
 326
 327
 328class Blast(bs.Actor):
 329    """An explosion, as generated by a bomb or some other object.
 330
 331    category: Gameplay Classes
 332    """
 333
 334    def __init__(
 335        self,
 336        position: Sequence[float] = (0.0, 1.0, 0.0),
 337        velocity: Sequence[float] = (0.0, 0.0, 0.0),
 338        blast_radius: float = 2.0,
 339        blast_type: str = 'normal',
 340        source_player: bs.Player | None = None,
 341        hit_type: str = 'explosion',
 342        hit_subtype: str = 'normal',
 343    ):
 344        """Instantiate with given values."""
 345
 346        # bah; get off my lawn!
 347        # pylint: disable=too-many-locals
 348        # pylint: disable=too-many-statements
 349
 350        super().__init__()
 351
 352        shared = SharedObjects.get()
 353        factory = BombFactory.get()
 354
 355        self.blast_type = blast_type
 356        self._source_player = source_player
 357        self.hit_type = hit_type
 358        self.hit_subtype = hit_subtype
 359        self.radius = blast_radius
 360
 361        # Set our position a bit lower so we throw more things upward.
 362        rmats = (factory.blast_material, shared.attack_material)
 363        self.node = bs.newnode(
 364            'region',
 365            delegate=self,
 366            attrs={
 367                'position': (position[0], position[1] - 0.1, position[2]),
 368                'scale': (self.radius, self.radius, self.radius),
 369                'type': 'sphere',
 370                'materials': rmats,
 371            },
 372        )
 373
 374        bs.timer(0.05, self.node.delete)
 375
 376        # Throw in an explosion and flash.
 377        evel = (velocity[0], max(-1.0, velocity[1]), velocity[2])
 378        explosion = bs.newnode(
 379            'explosion',
 380            attrs={
 381                'position': position,
 382                'velocity': evel,
 383                'radius': self.radius,
 384                'big': (self.blast_type == 'tnt'),
 385            },
 386        )
 387        if self.blast_type == 'ice':
 388            explosion.color = (0, 0.05, 0.4)
 389
 390        bs.timer(1.0, explosion.delete)
 391
 392        if self.blast_type != 'ice':
 393            bs.emitfx(
 394                position=position,
 395                velocity=velocity,
 396                count=int(1.0 + random.random() * 4),
 397                emit_type='tendrils',
 398                tendril_type='thin_smoke',
 399            )
 400        bs.emitfx(
 401            position=position,
 402            velocity=velocity,
 403            count=int(4.0 + random.random() * 4),
 404            emit_type='tendrils',
 405            tendril_type='ice' if self.blast_type == 'ice' else 'smoke',
 406        )
 407        bs.emitfx(
 408            position=position,
 409            emit_type='distortion',
 410            spread=1.0 if self.blast_type == 'tnt' else 2.0,
 411        )
 412
 413        # And emit some shrapnel.
 414        if self.blast_type == 'ice':
 415
 416            def emit() -> None:
 417                bs.emitfx(
 418                    position=position,
 419                    velocity=velocity,
 420                    count=30,
 421                    spread=2.0,
 422                    scale=0.4,
 423                    chunk_type='ice',
 424                    emit_type='stickers',
 425                )
 426
 427            # It looks better if we delay a bit.
 428            bs.timer(0.05, emit)
 429
 430        elif self.blast_type == 'sticky':
 431
 432            def emit() -> None:
 433                bs.emitfx(
 434                    position=position,
 435                    velocity=velocity,
 436                    count=int(4.0 + random.random() * 8),
 437                    spread=0.7,
 438                    chunk_type='slime',
 439                )
 440                bs.emitfx(
 441                    position=position,
 442                    velocity=velocity,
 443                    count=int(4.0 + random.random() * 8),
 444                    scale=0.5,
 445                    spread=0.7,
 446                    chunk_type='slime',
 447                )
 448                bs.emitfx(
 449                    position=position,
 450                    velocity=velocity,
 451                    count=15,
 452                    scale=0.6,
 453                    chunk_type='slime',
 454                    emit_type='stickers',
 455                )
 456                bs.emitfx(
 457                    position=position,
 458                    velocity=velocity,
 459                    count=20,
 460                    scale=0.7,
 461                    chunk_type='spark',
 462                    emit_type='stickers',
 463                )
 464                bs.emitfx(
 465                    position=position,
 466                    velocity=velocity,
 467                    count=int(6.0 + random.random() * 12),
 468                    scale=0.8,
 469                    spread=1.5,
 470                    chunk_type='spark',
 471                )
 472
 473            # It looks better if we delay a bit.
 474            bs.timer(0.05, emit)
 475
 476        elif self.blast_type == 'impact':
 477
 478            def emit() -> None:
 479                bs.emitfx(
 480                    position=position,
 481                    velocity=velocity,
 482                    count=int(4.0 + random.random() * 8),
 483                    scale=0.8,
 484                    chunk_type='metal',
 485                )
 486                bs.emitfx(
 487                    position=position,
 488                    velocity=velocity,
 489                    count=int(4.0 + random.random() * 8),
 490                    scale=0.4,
 491                    chunk_type='metal',
 492                )
 493                bs.emitfx(
 494                    position=position,
 495                    velocity=velocity,
 496                    count=20,
 497                    scale=0.7,
 498                    chunk_type='spark',
 499                    emit_type='stickers',
 500                )
 501                bs.emitfx(
 502                    position=position,
 503                    velocity=velocity,
 504                    count=int(8.0 + random.random() * 15),
 505                    scale=0.8,
 506                    spread=1.5,
 507                    chunk_type='spark',
 508                )
 509
 510            # It looks better if we delay a bit.
 511            bs.timer(0.05, emit)
 512
 513        else:  # Regular or land mine bomb shrapnel.
 514
 515            def emit() -> None:
 516                if self.blast_type != 'tnt':
 517                    bs.emitfx(
 518                        position=position,
 519                        velocity=velocity,
 520                        count=int(4.0 + random.random() * 8),
 521                        chunk_type='rock',
 522                    )
 523                    bs.emitfx(
 524                        position=position,
 525                        velocity=velocity,
 526                        count=int(4.0 + random.random() * 8),
 527                        scale=0.5,
 528                        chunk_type='rock',
 529                    )
 530                bs.emitfx(
 531                    position=position,
 532                    velocity=velocity,
 533                    count=30,
 534                    scale=1.0 if self.blast_type == 'tnt' else 0.7,
 535                    chunk_type='spark',
 536                    emit_type='stickers',
 537                )
 538                bs.emitfx(
 539                    position=position,
 540                    velocity=velocity,
 541                    count=int(18.0 + random.random() * 20),
 542                    scale=1.0 if self.blast_type == 'tnt' else 0.8,
 543                    spread=1.5,
 544                    chunk_type='spark',
 545                )
 546
 547                # TNT throws splintery chunks.
 548                if self.blast_type == 'tnt':
 549
 550                    def emit_splinters() -> None:
 551                        bs.emitfx(
 552                            position=position,
 553                            velocity=velocity,
 554                            count=int(20.0 + random.random() * 25),
 555                            scale=0.8,
 556                            spread=1.0,
 557                            chunk_type='splinter',
 558                        )
 559
 560                    bs.timer(0.01, emit_splinters)
 561
 562                # Every now and then do a sparky one.
 563                if self.blast_type == 'tnt' or random.random() < 0.1:
 564
 565                    def emit_extra_sparks() -> None:
 566                        bs.emitfx(
 567                            position=position,
 568                            velocity=velocity,
 569                            count=int(10.0 + random.random() * 20),
 570                            scale=0.8,
 571                            spread=1.5,
 572                            chunk_type='spark',
 573                        )
 574
 575                    bs.timer(0.02, emit_extra_sparks)
 576
 577            # It looks better if we delay a bit.
 578            bs.timer(0.05, emit)
 579
 580        lcolor = (0.6, 0.6, 1.0) if self.blast_type == 'ice' else (1, 0.3, 0.1)
 581        light = bs.newnode(
 582            'light',
 583            attrs={
 584                'position': position,
 585                'volume_intensity_scale': 10.0,
 586                'color': lcolor,
 587            },
 588        )
 589
 590        scl = random.uniform(0.6, 0.9)
 591        scorch_radius = light_radius = self.radius
 592        if self.blast_type == 'tnt':
 593            light_radius *= 1.4
 594            scorch_radius *= 1.15
 595            scl *= 3.0
 596
 597        iscale = 1.6
 598        bs.animate(
 599            light,
 600            'intensity',
 601            {
 602                0: 2.0 * iscale,
 603                scl * 0.02: 0.1 * iscale,
 604                scl * 0.025: 0.2 * iscale,
 605                scl * 0.05: 17.0 * iscale,
 606                scl * 0.06: 5.0 * iscale,
 607                scl * 0.08: 4.0 * iscale,
 608                scl * 0.2: 0.6 * iscale,
 609                scl * 2.0: 0.00 * iscale,
 610                scl * 3.0: 0.0,
 611            },
 612        )
 613        bs.animate(
 614            light,
 615            'radius',
 616            {
 617                0: light_radius * 0.2,
 618                scl * 0.05: light_radius * 0.55,
 619                scl * 0.1: light_radius * 0.3,
 620                scl * 0.3: light_radius * 0.15,
 621                scl * 1.0: light_radius * 0.05,
 622            },
 623        )
 624        bs.timer(scl * 3.0, light.delete)
 625
 626        # Make a scorch that fades over time.
 627        scorch = bs.newnode(
 628            'scorch',
 629            attrs={
 630                'position': position,
 631                'size': scorch_radius * 0.5,
 632                'big': (self.blast_type == 'tnt'),
 633            },
 634        )
 635        if self.blast_type == 'ice':
 636            scorch.color = (1, 1, 1.5)
 637
 638        bs.animate(scorch, 'presence', {3.000: 1, 13.000: 0})
 639        bs.timer(13.0, scorch.delete)
 640
 641        if self.blast_type == 'ice':
 642            factory.hiss_sound.play(position=light.position)
 643
 644        lpos = light.position
 645        factory.random_explode_sound().play(position=lpos)
 646        factory.debris_fall_sound.play(position=lpos)
 647
 648        bs.camerashake(intensity=5.0 if self.blast_type == 'tnt' else 1.0)
 649
 650        # TNT is more epic.
 651        if self.blast_type == 'tnt':
 652            factory.random_explode_sound().play(position=lpos)
 653
 654            def _extra_boom() -> None:
 655                factory.random_explode_sound().play(position=lpos)
 656
 657            bs.timer(0.25, _extra_boom)
 658
 659            def _extra_debris_sound() -> None:
 660                factory.debris_fall_sound.play(position=lpos)
 661                factory.wood_debris_fall_sound.play(position=lpos)
 662
 663            bs.timer(0.4, _extra_debris_sound)
 664
 665    @override
 666    def handlemessage(self, msg: Any) -> Any:
 667        assert not self.expired
 668
 669        if isinstance(msg, bs.DieMessage):
 670            if self.node:
 671                self.node.delete()
 672
 673        elif isinstance(msg, ExplodeHitMessage):
 674            node = bs.getcollision().opposingnode
 675            assert self.node
 676            nodepos = self.node.position
 677            mag = 2000.0
 678            if self.blast_type == 'ice':
 679                mag *= 0.5
 680            elif self.blast_type == 'land_mine':
 681                mag *= 2.5
 682            elif self.blast_type == 'tnt':
 683                mag *= 2.0
 684
 685            node.handlemessage(
 686                bs.HitMessage(
 687                    pos=nodepos,
 688                    velocity=(0, 0, 0),
 689                    magnitude=mag,
 690                    hit_type=self.hit_type,
 691                    hit_subtype=self.hit_subtype,
 692                    radius=self.radius,
 693                    source_player=bs.existing(self._source_player),
 694                )
 695            )
 696            if self.blast_type == 'ice':
 697                BombFactory.get().freeze_sound.play(10, position=nodepos)
 698                node.handlemessage(bs.FreezeMessage())
 699
 700        else:
 701            return super().handlemessage(msg)
 702        return None
 703
 704
 705class Bomb(bs.Actor):
 706    """A standard bomb and its variants such as land-mines and tnt-boxes.
 707
 708    category: Gameplay Classes
 709    """
 710
 711    # Ew; should try to clean this up later.
 712    # pylint: disable=too-many-locals
 713    # pylint: disable=too-many-branches
 714    # pylint: disable=too-many-statements
 715
 716    def __init__(
 717        self,
 718        position: Sequence[float] = (0.0, 1.0, 0.0),
 719        velocity: Sequence[float] = (0.0, 0.0, 0.0),
 720        bomb_type: str = 'normal',
 721        blast_radius: float = 2.0,
 722        bomb_scale: float = 1.0,
 723        source_player: bs.Player | None = None,
 724        owner: bs.Node | None = None,
 725    ):
 726        """Create a new Bomb.
 727
 728        bomb_type can be 'ice','impact','land_mine','normal','sticky', or
 729        'tnt'. Note that for impact or land_mine bombs you have to call arm()
 730        before they will go off.
 731        """
 732        super().__init__()
 733
 734        shared = SharedObjects.get()
 735        factory = BombFactory.get()
 736
 737        if bomb_type not in (
 738            'ice',
 739            'impact',
 740            'land_mine',
 741            'normal',
 742            'sticky',
 743            'tnt',
 744        ):
 745            raise ValueError('invalid bomb type: ' + bomb_type)
 746        self.bomb_type = bomb_type
 747
 748        self._exploded = False
 749        self.scale = bomb_scale
 750
 751        self.texture_sequence: bs.Node | None = None
 752
 753        if self.bomb_type == 'sticky':
 754            self._last_sticky_sound_time = 0.0
 755
 756        self.blast_radius = blast_radius
 757        if self.bomb_type == 'ice':
 758            self.blast_radius *= 1.2
 759        elif self.bomb_type == 'impact':
 760            self.blast_radius *= 0.7
 761        elif self.bomb_type == 'land_mine':
 762            self.blast_radius *= 0.7
 763        elif self.bomb_type == 'tnt':
 764            self.blast_radius *= 1.45
 765
 766        self._explode_callbacks: list[Callable[[Bomb, Blast], Any]] = []
 767
 768        # The player this came from.
 769        self._source_player = source_player
 770
 771        # By default our hit type/subtype is our own, but we pick up types of
 772        # whoever sets us off so we know what caused a chain reaction.
 773        # UPDATE (July 2020): not inheriting hit-types anymore; this causes
 774        # weird effects such as land-mines inheriting 'punch' hit types and
 775        # then not being able to destroy certain things they normally could,
 776        # etc. Inheriting owner/source-node from things that set us off
 777        # should be all we need I think...
 778        self.hit_type = 'explosion'
 779        self.hit_subtype = self.bomb_type
 780
 781        # The node this came from.
 782        # FIXME: can we unify this and source_player?
 783        self.owner = owner
 784
 785        # Adding footing-materials to things can screw up jumping and flying
 786        # since players carrying those things and thus touching footing
 787        # objects will think they're on solid ground.. perhaps we don't
 788        # wanna add this even in the tnt case?
 789        materials: tuple[bs.Material, ...]
 790        if self.bomb_type == 'tnt':
 791            materials = (
 792                factory.bomb_material,
 793                shared.footing_material,
 794                shared.object_material,
 795            )
 796        else:
 797            materials = (factory.bomb_material, shared.object_material)
 798
 799        if self.bomb_type == 'impact':
 800            materials = materials + (factory.impact_blast_material,)
 801        elif self.bomb_type == 'land_mine':
 802            materials = materials + (factory.land_mine_no_explode_material,)
 803
 804        if self.bomb_type == 'sticky':
 805            materials = materials + (factory.sticky_material,)
 806        else:
 807            materials = materials + (factory.normal_sound_material,)
 808
 809        if self.bomb_type == 'land_mine':
 810            fuse_time = None
 811            self.node = bs.newnode(
 812                'prop',
 813                delegate=self,
 814                attrs={
 815                    'position': position,
 816                    'velocity': velocity,
 817                    'mesh': factory.land_mine_mesh,
 818                    'light_mesh': factory.land_mine_mesh,
 819                    'body': 'landMine',
 820                    'body_scale': self.scale,
 821                    'shadow_size': 0.44,
 822                    'color_texture': factory.land_mine_tex,
 823                    'reflection': 'powerup',
 824                    'reflection_scale': [1.0],
 825                    'materials': materials,
 826                },
 827            )
 828
 829        elif self.bomb_type == 'tnt':
 830            fuse_time = None
 831            self.node = bs.newnode(
 832                'prop',
 833                delegate=self,
 834                attrs={
 835                    'position': position,
 836                    'velocity': velocity,
 837                    'mesh': factory.tnt_mesh,
 838                    'light_mesh': factory.tnt_mesh,
 839                    'body': 'crate',
 840                    'body_scale': self.scale,
 841                    'shadow_size': 0.5,
 842                    'color_texture': factory.tnt_tex,
 843                    'reflection': 'soft',
 844                    'reflection_scale': [0.23],
 845                    'materials': materials,
 846                },
 847            )
 848
 849        elif self.bomb_type == 'impact':
 850            fuse_time = 20.0
 851            self.node = bs.newnode(
 852                'prop',
 853                delegate=self,
 854                attrs={
 855                    'position': position,
 856                    'velocity': velocity,
 857                    'body': 'sphere',
 858                    'body_scale': self.scale,
 859                    'mesh': factory.impact_bomb_mesh,
 860                    'shadow_size': 0.3,
 861                    'color_texture': factory.impact_tex,
 862                    'reflection': 'powerup',
 863                    'reflection_scale': [1.5],
 864                    'materials': materials,
 865                },
 866            )
 867            self.arm_timer = bs.Timer(
 868                0.2, bs.WeakCall(self.handlemessage, ArmMessage())
 869            )
 870            self.warn_timer = bs.Timer(
 871                fuse_time - 1.7, bs.WeakCall(self.handlemessage, WarnMessage())
 872            )
 873
 874        else:
 875            fuse_time = 3.0
 876            if self.bomb_type == 'sticky':
 877                sticky = True
 878                mesh = factory.sticky_bomb_mesh
 879                rtype = 'sharper'
 880                rscale = 1.8
 881            else:
 882                sticky = False
 883                mesh = factory.bomb_mesh
 884                rtype = 'sharper'
 885                rscale = 1.8
 886            if self.bomb_type == 'ice':
 887                tex = factory.ice_tex
 888            elif self.bomb_type == 'sticky':
 889                tex = factory.sticky_tex
 890            else:
 891                tex = factory.regular_tex
 892            self.node = bs.newnode(
 893                'bomb',
 894                delegate=self,
 895                attrs={
 896                    'position': position,
 897                    'velocity': velocity,
 898                    'mesh': mesh,
 899                    'body_scale': self.scale,
 900                    'shadow_size': 0.3,
 901                    'color_texture': tex,
 902                    'sticky': sticky,
 903                    'owner': owner,
 904                    'reflection': rtype,
 905                    'reflection_scale': [rscale],
 906                    'materials': materials,
 907                },
 908            )
 909
 910            sound = bs.newnode(
 911                'sound',
 912                owner=self.node,
 913                attrs={'sound': factory.fuse_sound, 'volume': 0.25},
 914            )
 915            self.node.connectattr('position', sound, 'position')
 916            bs.animate(self.node, 'fuse_length', {0.0: 1.0, fuse_time: 0.0})
 917
 918        # Light the fuse!!!
 919        if self.bomb_type not in ('land_mine', 'tnt'):
 920            assert fuse_time is not None
 921            bs.timer(
 922                fuse_time, bs.WeakCall(self.handlemessage, ExplodeMessage())
 923            )
 924
 925        bs.animate(
 926            self.node,
 927            'mesh_scale',
 928            {0: 0, 0.2: 1.3 * self.scale, 0.26: self.scale},
 929        )
 930
 931    def get_source_player(self, playertype: type[PlayerT]) -> PlayerT | None:
 932        """Return the source-player if one exists and is the provided type."""
 933        player: Any = self._source_player
 934        return (
 935            player
 936            if isinstance(player, playertype) and player.exists()
 937            else None
 938        )
 939
 940    @override
 941    def on_expire(self) -> None:
 942        super().on_expire()
 943
 944        # Release callbacks/refs so we don't wind up with dependency loops.
 945        self._explode_callbacks = []
 946
 947    def _handle_die(self) -> None:
 948        if self.node:
 949            self.node.delete()
 950
 951    def _handle_oob(self) -> None:
 952        self.handlemessage(bs.DieMessage())
 953
 954    def _handle_impact(self) -> None:
 955        node = bs.getcollision().opposingnode
 956
 957        # If we're an impact bomb and we came from this node, don't explode.
 958        # (otherwise we blow up on our own head when jumping).
 959        # Alternately if we're hitting another impact-bomb from the same
 960        # source, don't explode. (can cause accidental explosions if rapidly
 961        # throwing/etc.)
 962        node_delegate = node.getdelegate(object)
 963        if node:
 964            if self.bomb_type == 'impact' and (
 965                node is self.owner
 966                or (
 967                    isinstance(node_delegate, Bomb)
 968                    and node_delegate.bomb_type == 'impact'
 969                    and node_delegate.owner is self.owner
 970                )
 971            ):
 972                return
 973            self.handlemessage(ExplodeMessage())
 974
 975    def _handle_dropped(self) -> None:
 976        if self.bomb_type == 'land_mine':
 977            self.arm_timer = bs.Timer(
 978                1.25, bs.WeakCall(self.handlemessage, ArmMessage())
 979            )
 980
 981        # Once we've thrown a sticky bomb we can stick to it.
 982        elif self.bomb_type == 'sticky':
 983
 984            def _setsticky(node: bs.Node) -> None:
 985                if node:
 986                    node.stick_to_owner = True
 987
 988            bs.timer(0.25, lambda: _setsticky(self.node))
 989
 990    def _handle_splat(self) -> None:
 991        node = bs.getcollision().opposingnode
 992        if (
 993            node is not self.owner
 994            and bs.time() - self._last_sticky_sound_time > 1.0
 995        ):
 996            self._last_sticky_sound_time = bs.time()
 997            assert self.node
 998            BombFactory.get().sticky_impact_sound.play(
 999                2.0,
1000                position=self.node.position,
1001            )
1002
1003    def add_explode_callback(self, call: Callable[[Bomb, Blast], Any]) -> None:
1004        """Add a call to be run when the bomb has exploded.
1005
1006        The bomb and the new blast object are passed as arguments.
1007        """
1008        self._explode_callbacks.append(call)
1009
1010    def explode(self) -> None:
1011        """Blows up the bomb if it has not yet done so."""
1012        if self._exploded:
1013            return
1014        self._exploded = True
1015        if self.node:
1016            blast = Blast(
1017                position=self.node.position,
1018                velocity=self.node.velocity,
1019                blast_radius=self.blast_radius,
1020                blast_type=self.bomb_type,
1021                source_player=bs.existing(self._source_player),
1022                hit_type=self.hit_type,
1023                hit_subtype=self.hit_subtype,
1024            ).autoretain()
1025            for callback in self._explode_callbacks:
1026                callback(self, blast)
1027
1028        # We blew up so we need to go away.
1029        # NOTE TO SELF: do we actually need this delay?
1030        bs.timer(0.001, bs.WeakCall(self.handlemessage, bs.DieMessage()))
1031
1032    def _handle_warn(self) -> None:
1033        if self.texture_sequence and self.node:
1034            self.texture_sequence.rate = 30
1035            BombFactory.get().warn_sound.play(0.5, position=self.node.position)
1036
1037    def _add_material(self, material: bs.Material) -> None:
1038        if not self.node:
1039            return
1040        materials = self.node.materials
1041        if material not in materials:
1042            assert isinstance(materials, tuple)
1043            self.node.materials = materials + (material,)
1044
1045    def arm(self) -> None:
1046        """Arm the bomb (for land-mines and impact-bombs).
1047
1048        These types of bombs will not explode until they have been armed.
1049        """
1050        if not self.node:
1051            return
1052        factory = BombFactory.get()
1053        intex: Sequence[bs.Texture]
1054        if self.bomb_type == 'land_mine':
1055            intex = (factory.land_mine_lit_tex, factory.land_mine_tex)
1056            self.texture_sequence = bs.newnode(
1057                'texture_sequence',
1058                owner=self.node,
1059                attrs={'rate': 30, 'input_textures': intex},
1060            )
1061            bs.timer(0.5, self.texture_sequence.delete)
1062
1063            # We now make it explodable.
1064            bs.timer(
1065                0.25,
1066                bs.WeakCall(
1067                    self._add_material, factory.land_mine_blast_material
1068                ),
1069            )
1070        elif self.bomb_type == 'impact':
1071            intex = (
1072                factory.impact_lit_tex,
1073                factory.impact_tex,
1074                factory.impact_tex,
1075            )
1076            self.texture_sequence = bs.newnode(
1077                'texture_sequence',
1078                owner=self.node,
1079                attrs={'rate': 100, 'input_textures': intex},
1080            )
1081            bs.timer(
1082                0.25,
1083                bs.WeakCall(
1084                    self._add_material, factory.land_mine_blast_material
1085                ),
1086            )
1087        else:
1088            raise RuntimeError(
1089                'arm() should only be called on land-mines or impact bombs'
1090            )
1091        self.texture_sequence.connectattr(
1092            'output_texture', self.node, 'color_texture'
1093        )
1094        factory.activate_sound.play(0.5, position=self.node.position)
1095
1096    def _handle_hit(self, msg: bs.HitMessage) -> None:
1097        ispunched = msg.srcnode and msg.srcnode.getnodetype() == 'spaz'
1098
1099        # Normal bombs are triggered by non-punch impacts;
1100        # impact-bombs by all impacts.
1101        if not self._exploded and (
1102            not ispunched or self.bomb_type in ['impact', 'land_mine']
1103        ):
1104            # Also lets change the owner of the bomb to whoever is setting
1105            # us off. (this way points for big chain reactions go to the
1106            # person causing them).
1107            source_player = msg.get_source_player(bs.Player)
1108            if source_player is not None:
1109                self._source_player = source_player
1110
1111                # Also inherit the hit type (if a landmine sets off by a bomb,
1112                # the credit should go to the mine)
1113                # the exception is TNT.  TNT always gets credit.
1114                # UPDATE (July 2020): not doing this anymore. Causes too much
1115                # weird logic such as bombs acting like punches. Holler if
1116                # anything is noticeably broken due to this.
1117                # if self.bomb_type != 'tnt':
1118                #     self.hit_type = msg.hit_type
1119                #     self.hit_subtype = msg.hit_subtype
1120
1121            bs.timer(
1122                0.1 + random.random() * 0.1,
1123                bs.WeakCall(self.handlemessage, ExplodeMessage()),
1124            )
1125        assert self.node
1126        self.node.handlemessage(
1127            'impulse',
1128            msg.pos[0],
1129            msg.pos[1],
1130            msg.pos[2],
1131            msg.velocity[0],
1132            msg.velocity[1],
1133            msg.velocity[2],
1134            msg.magnitude,
1135            msg.velocity_magnitude,
1136            msg.radius,
1137            0,
1138            msg.velocity[0],
1139            msg.velocity[1],
1140            msg.velocity[2],
1141        )
1142
1143        if msg.srcnode:
1144            pass
1145
1146    @override
1147    def handlemessage(self, msg: Any) -> Any:
1148        if isinstance(msg, ExplodeMessage):
1149            self.explode()
1150        elif isinstance(msg, ImpactMessage):
1151            self._handle_impact()
1152        elif isinstance(msg, bs.PickedUpMessage):
1153            # Change our source to whoever just picked us up *only* if it
1154            # is None. This way we can get points for killing bots with their
1155            # own bombs. Hmm would there be a downside to this?
1156            if self._source_player is None:
1157                self._source_player = msg.node.source_player
1158        elif isinstance(msg, SplatMessage):
1159            self._handle_splat()
1160        elif isinstance(msg, bs.DroppedMessage):
1161            self._handle_dropped()
1162        elif isinstance(msg, bs.HitMessage):
1163            self._handle_hit(msg)
1164        elif isinstance(msg, bs.DieMessage):
1165            self._handle_die()
1166        elif isinstance(msg, bs.OutOfBoundsMessage):
1167            self._handle_oob()
1168        elif isinstance(msg, ArmMessage):
1169            self.arm()
1170        elif isinstance(msg, WarnMessage):
1171            self._handle_warn()
1172        else:
1173            super().handlemessage(msg)
1174
1175
1176class TNTSpawner:
1177    """Regenerates TNT at a given point in space every now and then.
1178
1179    category: Gameplay Classes
1180    """
1181
1182    def __init__(self, position: Sequence[float], respawn_time: float = 20.0):
1183        """Instantiate with given position and respawn_time (in seconds)."""
1184        self._position = position
1185        self._tnt: Bomb | None = None
1186        self._respawn_time = random.uniform(0.8, 1.2) * respawn_time
1187        self._wait_time = 0.0
1188        self._update()
1189
1190        # Go with slightly more than 1 second to avoid timer stacking.
1191        self._update_timer = bs.Timer(
1192            1.1, bs.WeakCall(self._update), repeat=True
1193        )
1194
1195    def _update(self) -> None:
1196        tnt_alive = self._tnt is not None and self._tnt.node
1197        if not tnt_alive:
1198            # Respawn if its been long enough.. otherwise just increment our
1199            # how-long-since-we-died value.
1200            if self._tnt is None or self._wait_time >= self._respawn_time:
1201                self._tnt = Bomb(position=self._position, bomb_type='tnt')
1202                self._wait_time = 0.0
1203            else:
1204                self._wait_time += 1.1