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        *,
 337        position: Sequence[float] = (0.0, 1.0, 0.0),
 338        velocity: Sequence[float] = (0.0, 0.0, 0.0),
 339        blast_radius: float = 2.0,
 340        blast_type: str = 'normal',
 341        source_player: bs.Player | None = None,
 342        hit_type: str = 'explosion',
 343        hit_subtype: str = 'normal',
 344    ):
 345        """Instantiate with given values."""
 346
 347        # bah; get off my lawn!
 348        # pylint: disable=too-many-locals
 349        # pylint: disable=too-many-statements
 350
 351        super().__init__()
 352
 353        shared = SharedObjects.get()
 354        factory = BombFactory.get()
 355
 356        self.blast_type = blast_type
 357        self._source_player = source_player
 358        self.hit_type = hit_type
 359        self.hit_subtype = hit_subtype
 360        self.radius = blast_radius
 361
 362        # Set our position a bit lower so we throw more things upward.
 363        rmats = (factory.blast_material, shared.attack_material)
 364        self.node = bs.newnode(
 365            'region',
 366            delegate=self,
 367            attrs={
 368                'position': (position[0], position[1] - 0.1, position[2]),
 369                'scale': (self.radius, self.radius, self.radius),
 370                'type': 'sphere',
 371                'materials': rmats,
 372            },
 373        )
 374
 375        bs.timer(0.05, self.node.delete)
 376
 377        # Throw in an explosion and flash.
 378        evel = (velocity[0], max(-1.0, velocity[1]), velocity[2])
 379        explosion = bs.newnode(
 380            'explosion',
 381            attrs={
 382                'position': position,
 383                'velocity': evel,
 384                'radius': self.radius,
 385                'big': (self.blast_type == 'tnt'),
 386            },
 387        )
 388        if self.blast_type == 'ice':
 389            explosion.color = (0, 0.05, 0.4)
 390
 391        bs.timer(1.0, explosion.delete)
 392
 393        if self.blast_type != 'ice':
 394            bs.emitfx(
 395                position=position,
 396                velocity=velocity,
 397                count=int(1.0 + random.random() * 4),
 398                emit_type='tendrils',
 399                tendril_type='thin_smoke',
 400            )
 401        bs.emitfx(
 402            position=position,
 403            velocity=velocity,
 404            count=int(4.0 + random.random() * 4),
 405            emit_type='tendrils',
 406            tendril_type='ice' if self.blast_type == 'ice' else 'smoke',
 407        )
 408        bs.emitfx(
 409            position=position,
 410            emit_type='distortion',
 411            spread=1.0 if self.blast_type == 'tnt' else 2.0,
 412        )
 413
 414        # And emit some shrapnel.
 415        if self.blast_type == 'ice':
 416
 417            def emit() -> None:
 418                bs.emitfx(
 419                    position=position,
 420                    velocity=velocity,
 421                    count=30,
 422                    spread=2.0,
 423                    scale=0.4,
 424                    chunk_type='ice',
 425                    emit_type='stickers',
 426                )
 427
 428            # It looks better if we delay a bit.
 429            bs.timer(0.05, emit)
 430
 431        elif self.blast_type == 'sticky':
 432
 433            def emit() -> None:
 434                bs.emitfx(
 435                    position=position,
 436                    velocity=velocity,
 437                    count=int(4.0 + random.random() * 8),
 438                    spread=0.7,
 439                    chunk_type='slime',
 440                )
 441                bs.emitfx(
 442                    position=position,
 443                    velocity=velocity,
 444                    count=int(4.0 + random.random() * 8),
 445                    scale=0.5,
 446                    spread=0.7,
 447                    chunk_type='slime',
 448                )
 449                bs.emitfx(
 450                    position=position,
 451                    velocity=velocity,
 452                    count=15,
 453                    scale=0.6,
 454                    chunk_type='slime',
 455                    emit_type='stickers',
 456                )
 457                bs.emitfx(
 458                    position=position,
 459                    velocity=velocity,
 460                    count=20,
 461                    scale=0.7,
 462                    chunk_type='spark',
 463                    emit_type='stickers',
 464                )
 465                bs.emitfx(
 466                    position=position,
 467                    velocity=velocity,
 468                    count=int(6.0 + random.random() * 12),
 469                    scale=0.8,
 470                    spread=1.5,
 471                    chunk_type='spark',
 472                )
 473
 474            # It looks better if we delay a bit.
 475            bs.timer(0.05, emit)
 476
 477        elif self.blast_type == 'impact':
 478
 479            def emit() -> None:
 480                bs.emitfx(
 481                    position=position,
 482                    velocity=velocity,
 483                    count=int(4.0 + random.random() * 8),
 484                    scale=0.8,
 485                    chunk_type='metal',
 486                )
 487                bs.emitfx(
 488                    position=position,
 489                    velocity=velocity,
 490                    count=int(4.0 + random.random() * 8),
 491                    scale=0.4,
 492                    chunk_type='metal',
 493                )
 494                bs.emitfx(
 495                    position=position,
 496                    velocity=velocity,
 497                    count=20,
 498                    scale=0.7,
 499                    chunk_type='spark',
 500                    emit_type='stickers',
 501                )
 502                bs.emitfx(
 503                    position=position,
 504                    velocity=velocity,
 505                    count=int(8.0 + random.random() * 15),
 506                    scale=0.8,
 507                    spread=1.5,
 508                    chunk_type='spark',
 509                )
 510
 511            # It looks better if we delay a bit.
 512            bs.timer(0.05, emit)
 513
 514        else:  # Regular or land mine bomb shrapnel.
 515
 516            def emit() -> None:
 517                if self.blast_type != 'tnt':
 518                    bs.emitfx(
 519                        position=position,
 520                        velocity=velocity,
 521                        count=int(4.0 + random.random() * 8),
 522                        chunk_type='rock',
 523                    )
 524                    bs.emitfx(
 525                        position=position,
 526                        velocity=velocity,
 527                        count=int(4.0 + random.random() * 8),
 528                        scale=0.5,
 529                        chunk_type='rock',
 530                    )
 531                bs.emitfx(
 532                    position=position,
 533                    velocity=velocity,
 534                    count=30,
 535                    scale=1.0 if self.blast_type == 'tnt' else 0.7,
 536                    chunk_type='spark',
 537                    emit_type='stickers',
 538                )
 539                bs.emitfx(
 540                    position=position,
 541                    velocity=velocity,
 542                    count=int(18.0 + random.random() * 20),
 543                    scale=1.0 if self.blast_type == 'tnt' else 0.8,
 544                    spread=1.5,
 545                    chunk_type='spark',
 546                )
 547
 548                # TNT throws splintery chunks.
 549                if self.blast_type == 'tnt':
 550
 551                    def emit_splinters() -> None:
 552                        bs.emitfx(
 553                            position=position,
 554                            velocity=velocity,
 555                            count=int(20.0 + random.random() * 25),
 556                            scale=0.8,
 557                            spread=1.0,
 558                            chunk_type='splinter',
 559                        )
 560
 561                    bs.timer(0.01, emit_splinters)
 562
 563                # Every now and then do a sparky one.
 564                if self.blast_type == 'tnt' or random.random() < 0.1:
 565
 566                    def emit_extra_sparks() -> None:
 567                        bs.emitfx(
 568                            position=position,
 569                            velocity=velocity,
 570                            count=int(10.0 + random.random() * 20),
 571                            scale=0.8,
 572                            spread=1.5,
 573                            chunk_type='spark',
 574                        )
 575
 576                    bs.timer(0.02, emit_extra_sparks)
 577
 578            # It looks better if we delay a bit.
 579            bs.timer(0.05, emit)
 580
 581        lcolor = (0.6, 0.6, 1.0) if self.blast_type == 'ice' else (1, 0.3, 0.1)
 582        light = bs.newnode(
 583            'light',
 584            attrs={
 585                'position': position,
 586                'volume_intensity_scale': 10.0,
 587                'color': lcolor,
 588            },
 589        )
 590
 591        scl = random.uniform(0.6, 0.9)
 592        scorch_radius = light_radius = self.radius
 593        if self.blast_type == 'tnt':
 594            light_radius *= 1.4
 595            scorch_radius *= 1.15
 596            scl *= 3.0
 597
 598        iscale = 1.6
 599        bs.animate(
 600            light,
 601            'intensity',
 602            {
 603                0: 2.0 * iscale,
 604                scl * 0.02: 0.1 * iscale,
 605                scl * 0.025: 0.2 * iscale,
 606                scl * 0.05: 17.0 * iscale,
 607                scl * 0.06: 5.0 * iscale,
 608                scl * 0.08: 4.0 * iscale,
 609                scl * 0.2: 0.6 * iscale,
 610                scl * 2.0: 0.00 * iscale,
 611                scl * 3.0: 0.0,
 612            },
 613        )
 614        bs.animate(
 615            light,
 616            'radius',
 617            {
 618                0: light_radius * 0.2,
 619                scl * 0.05: light_radius * 0.55,
 620                scl * 0.1: light_radius * 0.3,
 621                scl * 0.3: light_radius * 0.15,
 622                scl * 1.0: light_radius * 0.05,
 623            },
 624        )
 625        bs.timer(scl * 3.0, light.delete)
 626
 627        # Make a scorch that fades over time.
 628        scorch = bs.newnode(
 629            'scorch',
 630            attrs={
 631                'position': position,
 632                'size': scorch_radius * 0.5,
 633                'big': (self.blast_type == 'tnt'),
 634            },
 635        )
 636        if self.blast_type == 'ice':
 637            scorch.color = (1, 1, 1.5)
 638
 639        bs.animate(scorch, 'presence', {3.000: 1, 13.000: 0})
 640        bs.timer(13.0, scorch.delete)
 641
 642        if self.blast_type == 'ice':
 643            factory.hiss_sound.play(position=light.position)
 644
 645        lpos = light.position
 646        factory.random_explode_sound().play(position=lpos)
 647        factory.debris_fall_sound.play(position=lpos)
 648
 649        bs.camerashake(intensity=5.0 if self.blast_type == 'tnt' else 1.0)
 650
 651        # TNT is more epic.
 652        if self.blast_type == 'tnt':
 653            factory.random_explode_sound().play(position=lpos)
 654
 655            def _extra_boom() -> None:
 656                factory.random_explode_sound().play(position=lpos)
 657
 658            bs.timer(0.25, _extra_boom)
 659
 660            def _extra_debris_sound() -> None:
 661                factory.debris_fall_sound.play(position=lpos)
 662                factory.wood_debris_fall_sound.play(position=lpos)
 663
 664            bs.timer(0.4, _extra_debris_sound)
 665
 666    @override
 667    def handlemessage(self, msg: Any) -> Any:
 668        assert not self.expired
 669
 670        if isinstance(msg, bs.DieMessage):
 671            if self.node:
 672                self.node.delete()
 673
 674        elif isinstance(msg, ExplodeHitMessage):
 675            node = bs.getcollision().opposingnode
 676            assert self.node
 677            nodepos = self.node.position
 678            mag = 2000.0
 679            if self.blast_type == 'ice':
 680                mag *= 0.5
 681            elif self.blast_type == 'land_mine':
 682                mag *= 2.5
 683            elif self.blast_type == 'tnt':
 684                mag *= 2.0
 685
 686            node.handlemessage(
 687                bs.HitMessage(
 688                    pos=nodepos,
 689                    velocity=(0, 0, 0),
 690                    magnitude=mag,
 691                    hit_type=self.hit_type,
 692                    hit_subtype=self.hit_subtype,
 693                    radius=self.radius,
 694                    source_player=bs.existing(self._source_player),
 695                )
 696            )
 697            if self.blast_type == 'ice':
 698                BombFactory.get().freeze_sound.play(10, position=nodepos)
 699                node.handlemessage(bs.FreezeMessage())
 700
 701        else:
 702            return super().handlemessage(msg)
 703        return None
 704
 705
 706class Bomb(bs.Actor):
 707    """A standard bomb and its variants such as land-mines and tnt-boxes.
 708
 709    category: Gameplay Classes
 710    """
 711
 712    # Ew; should try to clean this up later.
 713    # pylint: disable=too-many-locals
 714    # pylint: disable=too-many-branches
 715    # pylint: disable=too-many-statements
 716
 717    def __init__(
 718        self,
 719        *,
 720        position: Sequence[float] = (0.0, 1.0, 0.0),
 721        velocity: Sequence[float] = (0.0, 0.0, 0.0),
 722        bomb_type: str = 'normal',
 723        blast_radius: float = 2.0,
 724        bomb_scale: float = 1.0,
 725        source_player: bs.Player | None = None,
 726        owner: bs.Node | None = None,
 727    ):
 728        """Create a new Bomb.
 729
 730        bomb_type can be 'ice','impact','land_mine','normal','sticky', or
 731        'tnt'. Note that for impact or land_mine bombs you have to call arm()
 732        before they will go off.
 733        """
 734        super().__init__()
 735
 736        shared = SharedObjects.get()
 737        factory = BombFactory.get()
 738
 739        if bomb_type not in (
 740            'ice',
 741            'impact',
 742            'land_mine',
 743            'normal',
 744            'sticky',
 745            'tnt',
 746        ):
 747            raise ValueError('invalid bomb type: ' + bomb_type)
 748        self.bomb_type = bomb_type
 749
 750        self._exploded = False
 751        self.scale = bomb_scale
 752
 753        self.texture_sequence: bs.Node | None = None
 754
 755        if self.bomb_type == 'sticky':
 756            self._last_sticky_sound_time = 0.0
 757
 758        self.blast_radius = blast_radius
 759        if self.bomb_type == 'ice':
 760            self.blast_radius *= 1.2
 761        elif self.bomb_type == 'impact':
 762            self.blast_radius *= 0.7
 763        elif self.bomb_type == 'land_mine':
 764            self.blast_radius *= 0.7
 765        elif self.bomb_type == 'tnt':
 766            self.blast_radius *= 1.45
 767
 768        self._explode_callbacks: list[Callable[[Bomb, Blast], Any]] = []
 769
 770        # The player this came from.
 771        self._source_player = source_player
 772
 773        # By default our hit type/subtype is our own, but we pick up types of
 774        # whoever sets us off so we know what caused a chain reaction.
 775        # UPDATE (July 2020): not inheriting hit-types anymore; this causes
 776        # weird effects such as land-mines inheriting 'punch' hit types and
 777        # then not being able to destroy certain things they normally could,
 778        # etc. Inheriting owner/source-node from things that set us off
 779        # should be all we need I think...
 780        self.hit_type = 'explosion'
 781        self.hit_subtype = self.bomb_type
 782
 783        # The node this came from.
 784        # FIXME: can we unify this and source_player?
 785        self.owner = owner
 786
 787        # Adding footing-materials to things can screw up jumping and flying
 788        # since players carrying those things and thus touching footing
 789        # objects will think they're on solid ground.. perhaps we don't
 790        # wanna add this even in the tnt case?
 791        materials: tuple[bs.Material, ...]
 792        if self.bomb_type == 'tnt':
 793            materials = (
 794                factory.bomb_material,
 795                shared.footing_material,
 796                shared.object_material,
 797            )
 798        else:
 799            materials = (factory.bomb_material, shared.object_material)
 800
 801        if self.bomb_type == 'impact':
 802            materials = materials + (factory.impact_blast_material,)
 803        elif self.bomb_type == 'land_mine':
 804            materials = materials + (factory.land_mine_no_explode_material,)
 805
 806        if self.bomb_type == 'sticky':
 807            materials = materials + (factory.sticky_material,)
 808        else:
 809            materials = materials + (factory.normal_sound_material,)
 810
 811        if self.bomb_type == 'land_mine':
 812            fuse_time = None
 813            self.node = bs.newnode(
 814                'prop',
 815                delegate=self,
 816                attrs={
 817                    'position': position,
 818                    'velocity': velocity,
 819                    'mesh': factory.land_mine_mesh,
 820                    'light_mesh': factory.land_mine_mesh,
 821                    'body': 'landMine',
 822                    'body_scale': self.scale,
 823                    'shadow_size': 0.44,
 824                    'color_texture': factory.land_mine_tex,
 825                    'reflection': 'powerup',
 826                    'reflection_scale': [1.0],
 827                    'materials': materials,
 828                },
 829            )
 830
 831        elif self.bomb_type == 'tnt':
 832            fuse_time = None
 833            self.node = bs.newnode(
 834                'prop',
 835                delegate=self,
 836                attrs={
 837                    'position': position,
 838                    'velocity': velocity,
 839                    'mesh': factory.tnt_mesh,
 840                    'light_mesh': factory.tnt_mesh,
 841                    'body': 'crate',
 842                    'body_scale': self.scale,
 843                    'shadow_size': 0.5,
 844                    'color_texture': factory.tnt_tex,
 845                    'reflection': 'soft',
 846                    'reflection_scale': [0.23],
 847                    'materials': materials,
 848                },
 849            )
 850
 851        elif self.bomb_type == 'impact':
 852            fuse_time = 20.0
 853            self.node = bs.newnode(
 854                'prop',
 855                delegate=self,
 856                attrs={
 857                    'position': position,
 858                    'velocity': velocity,
 859                    'body': 'sphere',
 860                    'body_scale': self.scale,
 861                    'mesh': factory.impact_bomb_mesh,
 862                    'shadow_size': 0.3,
 863                    'color_texture': factory.impact_tex,
 864                    'reflection': 'powerup',
 865                    'reflection_scale': [1.5],
 866                    'materials': materials,
 867                },
 868            )
 869            self.arm_timer = bs.Timer(
 870                0.2, bs.WeakCall(self.handlemessage, ArmMessage())
 871            )
 872            self.warn_timer = bs.Timer(
 873                fuse_time - 1.7, bs.WeakCall(self.handlemessage, WarnMessage())
 874            )
 875
 876        else:
 877            fuse_time = 3.0
 878            if self.bomb_type == 'sticky':
 879                sticky = True
 880                mesh = factory.sticky_bomb_mesh
 881                rtype = 'sharper'
 882                rscale = 1.8
 883            else:
 884                sticky = False
 885                mesh = factory.bomb_mesh
 886                rtype = 'sharper'
 887                rscale = 1.8
 888            if self.bomb_type == 'ice':
 889                tex = factory.ice_tex
 890            elif self.bomb_type == 'sticky':
 891                tex = factory.sticky_tex
 892            else:
 893                tex = factory.regular_tex
 894            self.node = bs.newnode(
 895                'bomb',
 896                delegate=self,
 897                attrs={
 898                    'position': position,
 899                    'velocity': velocity,
 900                    'mesh': mesh,
 901                    'body_scale': self.scale,
 902                    'shadow_size': 0.3,
 903                    'color_texture': tex,
 904                    'sticky': sticky,
 905                    'owner': owner,
 906                    'reflection': rtype,
 907                    'reflection_scale': [rscale],
 908                    'materials': materials,
 909                },
 910            )
 911
 912            sound = bs.newnode(
 913                'sound',
 914                owner=self.node,
 915                attrs={'sound': factory.fuse_sound, 'volume': 0.25},
 916            )
 917            self.node.connectattr('position', sound, 'position')
 918            bs.animate(self.node, 'fuse_length', {0.0: 1.0, fuse_time: 0.0})
 919
 920        # Light the fuse!!!
 921        if self.bomb_type not in ('land_mine', 'tnt'):
 922            assert fuse_time is not None
 923            bs.timer(
 924                fuse_time, bs.WeakCall(self.handlemessage, ExplodeMessage())
 925            )
 926
 927        bs.animate(
 928            self.node,
 929            'mesh_scale',
 930            {0: 0, 0.2: 1.3 * self.scale, 0.26: self.scale},
 931        )
 932
 933    def get_source_player(self, playertype: type[PlayerT]) -> PlayerT | None:
 934        """Return the source-player if one exists and is the provided type."""
 935        player: Any = self._source_player
 936        return (
 937            player
 938            if isinstance(player, playertype) and player.exists()
 939            else None
 940        )
 941
 942    @override
 943    def on_expire(self) -> None:
 944        super().on_expire()
 945
 946        # Release callbacks/refs so we don't wind up with dependency loops.
 947        self._explode_callbacks = []
 948
 949    def _handle_die(self) -> None:
 950        if self.node:
 951            self.node.delete()
 952
 953    def _handle_oob(self) -> None:
 954        self.handlemessage(bs.DieMessage())
 955
 956    def _handle_impact(self) -> None:
 957        node = bs.getcollision().opposingnode
 958
 959        # If we're an impact bomb and we came from this node, don't explode.
 960        # (otherwise we blow up on our own head when jumping).
 961        # Alternately if we're hitting another impact-bomb from the same
 962        # source, don't explode. (can cause accidental explosions if rapidly
 963        # throwing/etc.)
 964        node_delegate = node.getdelegate(object)
 965        if node:
 966            if self.bomb_type == 'impact' and (
 967                node is self.owner
 968                or (
 969                    isinstance(node_delegate, Bomb)
 970                    and node_delegate.bomb_type == 'impact'
 971                    and node_delegate.owner is self.owner
 972                )
 973            ):
 974                return
 975            self.handlemessage(ExplodeMessage())
 976
 977    def _handle_dropped(self) -> None:
 978        if self.bomb_type == 'land_mine':
 979            self.arm_timer = bs.Timer(
 980                1.25, bs.WeakCall(self.handlemessage, ArmMessage())
 981            )
 982
 983        # Once we've thrown a sticky bomb we can stick to it.
 984        elif self.bomb_type == 'sticky':
 985
 986            def _setsticky(node: bs.Node) -> None:
 987                if node:
 988                    node.stick_to_owner = True
 989
 990            bs.timer(0.25, lambda: _setsticky(self.node))
 991
 992    def _handle_splat(self) -> None:
 993        node = bs.getcollision().opposingnode
 994        if (
 995            node is not self.owner
 996            and bs.time() - self._last_sticky_sound_time > 1.0
 997        ):
 998            self._last_sticky_sound_time = bs.time()
 999            assert self.node
1000            BombFactory.get().sticky_impact_sound.play(
1001                2.0,
1002                position=self.node.position,
1003            )
1004
1005    def add_explode_callback(self, call: Callable[[Bomb, Blast], Any]) -> None:
1006        """Add a call to be run when the bomb has exploded.
1007
1008        The bomb and the new blast object are passed as arguments.
1009        """
1010        self._explode_callbacks.append(call)
1011
1012    def explode(self) -> None:
1013        """Blows up the bomb if it has not yet done so."""
1014        if self._exploded:
1015            return
1016        self._exploded = True
1017        if self.node:
1018            blast = Blast(
1019                position=self.node.position,
1020                velocity=self.node.velocity,
1021                blast_radius=self.blast_radius,
1022                blast_type=self.bomb_type,
1023                source_player=bs.existing(self._source_player),
1024                hit_type=self.hit_type,
1025                hit_subtype=self.hit_subtype,
1026            ).autoretain()
1027            for callback in self._explode_callbacks:
1028                callback(self, blast)
1029
1030        # We blew up so we need to go away.
1031        # NOTE TO SELF: do we actually need this delay?
1032        bs.timer(0.001, bs.WeakCall(self.handlemessage, bs.DieMessage()))
1033
1034    def _handle_warn(self) -> None:
1035        if self.texture_sequence and self.node:
1036            self.texture_sequence.rate = 30
1037            BombFactory.get().warn_sound.play(0.5, position=self.node.position)
1038
1039    def _add_material(self, material: bs.Material) -> None:
1040        if not self.node:
1041            return
1042        materials = self.node.materials
1043        if material not in materials:
1044            assert isinstance(materials, tuple)
1045            self.node.materials = materials + (material,)
1046
1047    def arm(self) -> None:
1048        """Arm the bomb (for land-mines and impact-bombs).
1049
1050        These types of bombs will not explode until they have been armed.
1051        """
1052        if not self.node:
1053            return
1054        factory = BombFactory.get()
1055        intex: Sequence[bs.Texture]
1056        if self.bomb_type == 'land_mine':
1057            intex = (factory.land_mine_lit_tex, factory.land_mine_tex)
1058            self.texture_sequence = bs.newnode(
1059                'texture_sequence',
1060                owner=self.node,
1061                attrs={'rate': 30, 'input_textures': intex},
1062            )
1063            bs.timer(0.5, self.texture_sequence.delete)
1064
1065            # We now make it explodable.
1066            bs.timer(
1067                0.25,
1068                bs.WeakCall(
1069                    self._add_material, factory.land_mine_blast_material
1070                ),
1071            )
1072        elif self.bomb_type == 'impact':
1073            intex = (
1074                factory.impact_lit_tex,
1075                factory.impact_tex,
1076                factory.impact_tex,
1077            )
1078            self.texture_sequence = bs.newnode(
1079                'texture_sequence',
1080                owner=self.node,
1081                attrs={'rate': 100, 'input_textures': intex},
1082            )
1083            bs.timer(
1084                0.25,
1085                bs.WeakCall(
1086                    self._add_material, factory.land_mine_blast_material
1087                ),
1088            )
1089        else:
1090            raise RuntimeError(
1091                'arm() should only be called on land-mines or impact bombs'
1092            )
1093        self.texture_sequence.connectattr(
1094            'output_texture', self.node, 'color_texture'
1095        )
1096        factory.activate_sound.play(0.5, position=self.node.position)
1097
1098    def _handle_hit(self, msg: bs.HitMessage) -> None:
1099        ispunched = msg.srcnode and msg.srcnode.getnodetype() == 'spaz'
1100
1101        # Normal bombs are triggered by non-punch impacts;
1102        # impact-bombs by all impacts.
1103        if not self._exploded and (
1104            not ispunched or self.bomb_type in ['impact', 'land_mine']
1105        ):
1106            # Also lets change the owner of the bomb to whoever is setting
1107            # us off. (this way points for big chain reactions go to the
1108            # person causing them).
1109            source_player = msg.get_source_player(bs.Player)
1110            if source_player is not None:
1111                self._source_player = source_player
1112
1113                # Also inherit the hit type (if a landmine sets off by a bomb,
1114                # the credit should go to the mine)
1115                # the exception is TNT.  TNT always gets credit.
1116                # UPDATE (July 2020): not doing this anymore. Causes too much
1117                # weird logic such as bombs acting like punches. Holler if
1118                # anything is noticeably broken due to this.
1119                # if self.bomb_type != 'tnt':
1120                #     self.hit_type = msg.hit_type
1121                #     self.hit_subtype = msg.hit_subtype
1122
1123            bs.timer(
1124                0.1 + random.random() * 0.1,
1125                bs.WeakCall(self.handlemessage, ExplodeMessage()),
1126            )
1127        assert self.node
1128        self.node.handlemessage(
1129            'impulse',
1130            msg.pos[0],
1131            msg.pos[1],
1132            msg.pos[2],
1133            msg.velocity[0],
1134            msg.velocity[1],
1135            msg.velocity[2],
1136            msg.magnitude,
1137            msg.velocity_magnitude,
1138            msg.radius,
1139            0,
1140            msg.velocity[0],
1141            msg.velocity[1],
1142            msg.velocity[2],
1143        )
1144
1145        if msg.srcnode:
1146            pass
1147
1148    @override
1149    def handlemessage(self, msg: Any) -> Any:
1150        if isinstance(msg, ExplodeMessage):
1151            self.explode()
1152        elif isinstance(msg, ImpactMessage):
1153            self._handle_impact()
1154        elif isinstance(msg, bs.PickedUpMessage):
1155            # Change our source to whoever just picked us up *only* if it
1156            # is None. This way we can get points for killing bots with their
1157            # own bombs. Hmm would there be a downside to this?
1158            if self._source_player is None:
1159                self._source_player = msg.node.source_player
1160        elif isinstance(msg, SplatMessage):
1161            self._handle_splat()
1162        elif isinstance(msg, bs.DroppedMessage):
1163            self._handle_dropped()
1164        elif isinstance(msg, bs.HitMessage):
1165            self._handle_hit(msg)
1166        elif isinstance(msg, bs.DieMessage):
1167            self._handle_die()
1168        elif isinstance(msg, bs.OutOfBoundsMessage):
1169            self._handle_oob()
1170        elif isinstance(msg, ArmMessage):
1171            self.arm()
1172        elif isinstance(msg, WarnMessage):
1173            self._handle_warn()
1174        else:
1175            super().handlemessage(msg)
1176
1177
1178class TNTSpawner:
1179    """Regenerates TNT at a given point in space every now and then.
1180
1181    category: Gameplay Classes
1182    """
1183
1184    def __init__(self, position: Sequence[float], respawn_time: float = 20.0):
1185        """Instantiate with given position and respawn_time (in seconds)."""
1186        self._position = position
1187        self._tnt: Bomb | None = None
1188        self._respawn_time = random.uniform(0.8, 1.2) * respawn_time
1189        self._wait_time = 0.0
1190        self._update()
1191
1192        # Go with slightly more than 1 second to avoid timer stacking.
1193        self._update_timer = bs.Timer(
1194            1.1, bs.WeakCall(self._update), repeat=True
1195        )
1196
1197    def _update(self) -> None:
1198        tnt_alive = self._tnt is not None and self._tnt.node
1199        if not tnt_alive:
1200            # Respawn if its been long enough.. otherwise just increment our
1201            # how-long-since-we-died value.
1202            if self._tnt is None or self._wait_time >= self._respawn_time:
1203                self._tnt = Bomb(position=self._position, bomb_type='tnt')
1204                self._wait_time = 0.0
1205            else:
1206                self._wait_time += 1.1