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