bastd.maps

   1# Released under the MIT License. See LICENSE for details.
   2#
   3"""Standard maps."""
   4# pylint: disable=too-many-lines
   5
   6from __future__ import annotations
   7
   8from typing import TYPE_CHECKING
   9
  10import ba
  11from bastd.gameutils import SharedObjects
  12
  13if TYPE_CHECKING:
  14    from typing import Any
  15
  16
  17class HockeyStadium(ba.Map):
  18    """Stadium map used for ice hockey games."""
  19
  20    from bastd.mapdata import hockey_stadium as defs
  21
  22    name = 'Hockey Stadium'
  23
  24    @classmethod
  25    def get_play_types(cls) -> list[str]:
  26        """Return valid play types for this map."""
  27        return ['melee', 'hockey', 'team_flag', 'keep_away']
  28
  29    @classmethod
  30    def get_preview_texture_name(cls) -> str:
  31        return 'hockeyStadiumPreview'
  32
  33    @classmethod
  34    def on_preload(cls) -> Any:
  35        data: dict[str, Any] = {
  36            'models': (
  37                ba.getmodel('hockeyStadiumOuter'),
  38                ba.getmodel('hockeyStadiumInner'),
  39                ba.getmodel('hockeyStadiumStands'),
  40            ),
  41            'vr_fill_model': ba.getmodel('footballStadiumVRFill'),
  42            'collide_model': ba.getcollidemodel('hockeyStadiumCollide'),
  43            'tex': ba.gettexture('hockeyStadium'),
  44            'stands_tex': ba.gettexture('footballStadium'),
  45        }
  46        mat = ba.Material()
  47        mat.add_actions(actions=('modify_part_collision', 'friction', 0.01))
  48        data['ice_material'] = mat
  49        return data
  50
  51    def __init__(self) -> None:
  52        super().__init__()
  53        shared = SharedObjects.get()
  54        self.node = ba.newnode(
  55            'terrain',
  56            delegate=self,
  57            attrs={
  58                'model': self.preloaddata['models'][0],
  59                'collide_model': self.preloaddata['collide_model'],
  60                'color_texture': self.preloaddata['tex'],
  61                'materials': [
  62                    shared.footing_material,
  63                    self.preloaddata['ice_material'],
  64                ],
  65            },
  66        )
  67        ba.newnode(
  68            'terrain',
  69            attrs={
  70                'model': self.preloaddata['vr_fill_model'],
  71                'vr_only': True,
  72                'lighting': False,
  73                'background': True,
  74                'color_texture': self.preloaddata['stands_tex'],
  75            },
  76        )
  77        mats = [shared.footing_material, self.preloaddata['ice_material']]
  78        self.floor = ba.newnode(
  79            'terrain',
  80            attrs={
  81                'model': self.preloaddata['models'][1],
  82                'color_texture': self.preloaddata['tex'],
  83                'opacity': 0.92,
  84                'opacity_in_low_or_medium_quality': 1.0,
  85                'materials': mats,
  86            },
  87        )
  88        self.stands = ba.newnode(
  89            'terrain',
  90            attrs={
  91                'model': self.preloaddata['models'][2],
  92                'visible_in_reflections': False,
  93                'color_texture': self.preloaddata['stands_tex'],
  94            },
  95        )
  96        gnode = ba.getactivity().globalsnode
  97        gnode.floor_reflection = True
  98        gnode.debris_friction = 0.3
  99        gnode.debris_kill_height = -0.3
 100        gnode.tint = (1.2, 1.3, 1.33)
 101        gnode.ambient_color = (1.15, 1.25, 1.6)
 102        gnode.vignette_outer = (0.66, 0.67, 0.73)
 103        gnode.vignette_inner = (0.93, 0.93, 0.95)
 104        gnode.vr_camera_offset = (0, -0.8, -1.1)
 105        gnode.vr_near_clip = 0.5
 106        self.is_hockey = True
 107
 108
 109class FootballStadium(ba.Map):
 110    """Stadium map for football games."""
 111
 112    from bastd.mapdata import football_stadium as defs
 113
 114    name = 'Football Stadium'
 115
 116    @classmethod
 117    def get_play_types(cls) -> list[str]:
 118        """Return valid play types for this map."""
 119        return ['melee', 'football', 'team_flag', 'keep_away']
 120
 121    @classmethod
 122    def get_preview_texture_name(cls) -> str:
 123        return 'footballStadiumPreview'
 124
 125    @classmethod
 126    def on_preload(cls) -> Any:
 127        data: dict[str, Any] = {
 128            'model': ba.getmodel('footballStadium'),
 129            'vr_fill_model': ba.getmodel('footballStadiumVRFill'),
 130            'collide_model': ba.getcollidemodel('footballStadiumCollide'),
 131            'tex': ba.gettexture('footballStadium'),
 132        }
 133        return data
 134
 135    def __init__(self) -> None:
 136        super().__init__()
 137        shared = SharedObjects.get()
 138        self.node = ba.newnode(
 139            'terrain',
 140            delegate=self,
 141            attrs={
 142                'model': self.preloaddata['model'],
 143                'collide_model': self.preloaddata['collide_model'],
 144                'color_texture': self.preloaddata['tex'],
 145                'materials': [shared.footing_material],
 146            },
 147        )
 148        ba.newnode(
 149            'terrain',
 150            attrs={
 151                'model': self.preloaddata['vr_fill_model'],
 152                'lighting': False,
 153                'vr_only': True,
 154                'background': True,
 155                'color_texture': self.preloaddata['tex'],
 156            },
 157        )
 158        gnode = ba.getactivity().globalsnode
 159        gnode.tint = (1.3, 1.2, 1.0)
 160        gnode.ambient_color = (1.3, 1.2, 1.0)
 161        gnode.vignette_outer = (0.57, 0.57, 0.57)
 162        gnode.vignette_inner = (0.9, 0.9, 0.9)
 163        gnode.vr_camera_offset = (0, -0.8, -1.1)
 164        gnode.vr_near_clip = 0.5
 165
 166    def is_point_near_edge(self, point: ba.Vec3, running: bool = False) -> bool:
 167        box_position = self.defs.boxes['edge_box'][0:3]
 168        box_scale = self.defs.boxes['edge_box'][6:9]
 169        xpos = (point.x - box_position[0]) / box_scale[0]
 170        zpos = (point.z - box_position[2]) / box_scale[2]
 171        return xpos < -0.5 or xpos > 0.5 or zpos < -0.5 or zpos > 0.5
 172
 173
 174class Bridgit(ba.Map):
 175    """Map with a narrow bridge in the middle."""
 176
 177    from bastd.mapdata import bridgit as defs
 178
 179    name = 'Bridgit'
 180    dataname = 'bridgit'
 181
 182    @classmethod
 183    def get_play_types(cls) -> list[str]:
 184        """Return valid play types for this map."""
 185        # print('getting playtypes', cls._getdata()['play_types'])
 186        return ['melee', 'team_flag', 'keep_away']
 187
 188    @classmethod
 189    def get_preview_texture_name(cls) -> str:
 190        return 'bridgitPreview'
 191
 192    @classmethod
 193    def on_preload(cls) -> Any:
 194        data: dict[str, Any] = {
 195            'model_top': ba.getmodel('bridgitLevelTop'),
 196            'model_bottom': ba.getmodel('bridgitLevelBottom'),
 197            'model_bg': ba.getmodel('natureBackground'),
 198            'bg_vr_fill_model': ba.getmodel('natureBackgroundVRFill'),
 199            'collide_model': ba.getcollidemodel('bridgitLevelCollide'),
 200            'tex': ba.gettexture('bridgitLevelColor'),
 201            'model_bg_tex': ba.gettexture('natureBackgroundColor'),
 202            'collide_bg': ba.getcollidemodel('natureBackgroundCollide'),
 203            'railing_collide_model': (
 204                ba.getcollidemodel('bridgitLevelRailingCollide')
 205            ),
 206            'bg_material': ba.Material(),
 207        }
 208        data['bg_material'].add_actions(
 209            actions=('modify_part_collision', 'friction', 10.0)
 210        )
 211        return data
 212
 213    def __init__(self) -> None:
 214        super().__init__()
 215        shared = SharedObjects.get()
 216        self.node = ba.newnode(
 217            'terrain',
 218            delegate=self,
 219            attrs={
 220                'collide_model': self.preloaddata['collide_model'],
 221                'model': self.preloaddata['model_top'],
 222                'color_texture': self.preloaddata['tex'],
 223                'materials': [shared.footing_material],
 224            },
 225        )
 226        self.bottom = ba.newnode(
 227            'terrain',
 228            attrs={
 229                'model': self.preloaddata['model_bottom'],
 230                'lighting': False,
 231                'color_texture': self.preloaddata['tex'],
 232            },
 233        )
 234        self.background = ba.newnode(
 235            'terrain',
 236            attrs={
 237                'model': self.preloaddata['model_bg'],
 238                'lighting': False,
 239                'background': True,
 240                'color_texture': self.preloaddata['model_bg_tex'],
 241            },
 242        )
 243        ba.newnode(
 244            'terrain',
 245            attrs={
 246                'model': self.preloaddata['bg_vr_fill_model'],
 247                'lighting': False,
 248                'vr_only': True,
 249                'background': True,
 250                'color_texture': self.preloaddata['model_bg_tex'],
 251            },
 252        )
 253        self.railing = ba.newnode(
 254            'terrain',
 255            attrs={
 256                'collide_model': self.preloaddata['railing_collide_model'],
 257                'materials': [shared.railing_material],
 258                'bumper': True,
 259            },
 260        )
 261        self.bg_collide = ba.newnode(
 262            'terrain',
 263            attrs={
 264                'collide_model': self.preloaddata['collide_bg'],
 265                'materials': [
 266                    shared.footing_material,
 267                    self.preloaddata['bg_material'],
 268                    shared.death_material,
 269                ],
 270            },
 271        )
 272        gnode = ba.getactivity().globalsnode
 273        gnode.tint = (1.1, 1.2, 1.3)
 274        gnode.ambient_color = (1.1, 1.2, 1.3)
 275        gnode.vignette_outer = (0.65, 0.6, 0.55)
 276        gnode.vignette_inner = (0.9, 0.9, 0.93)
 277
 278
 279class BigG(ba.Map):
 280    """Large G shaped map for racing"""
 281
 282    from bastd.mapdata import big_g as defs
 283
 284    name = 'Big G'
 285
 286    @classmethod
 287    def get_play_types(cls) -> list[str]:
 288        """Return valid play types for this map."""
 289        return [
 290            'race',
 291            'melee',
 292            'keep_away',
 293            'team_flag',
 294            'king_of_the_hill',
 295            'conquest',
 296        ]
 297
 298    @classmethod
 299    def get_preview_texture_name(cls) -> str:
 300        return 'bigGPreview'
 301
 302    @classmethod
 303    def on_preload(cls) -> Any:
 304        data: dict[str, Any] = {
 305            'model_top': ba.getmodel('bigG'),
 306            'model_bottom': ba.getmodel('bigGBottom'),
 307            'model_bg': ba.getmodel('natureBackground'),
 308            'bg_vr_fill_model': ba.getmodel('natureBackgroundVRFill'),
 309            'collide_model': ba.getcollidemodel('bigGCollide'),
 310            'tex': ba.gettexture('bigG'),
 311            'model_bg_tex': ba.gettexture('natureBackgroundColor'),
 312            'collide_bg': ba.getcollidemodel('natureBackgroundCollide'),
 313            'bumper_collide_model': ba.getcollidemodel('bigGBumper'),
 314            'bg_material': ba.Material(),
 315        }
 316        data['bg_material'].add_actions(
 317            actions=('modify_part_collision', 'friction', 10.0)
 318        )
 319        return data
 320
 321    def __init__(self) -> None:
 322        super().__init__()
 323        shared = SharedObjects.get()
 324        self.node = ba.newnode(
 325            'terrain',
 326            delegate=self,
 327            attrs={
 328                'collide_model': self.preloaddata['collide_model'],
 329                'color': (0.7, 0.7, 0.7),
 330                'model': self.preloaddata['model_top'],
 331                'color_texture': self.preloaddata['tex'],
 332                'materials': [shared.footing_material],
 333            },
 334        )
 335        self.bottom = ba.newnode(
 336            'terrain',
 337            attrs={
 338                'model': self.preloaddata['model_bottom'],
 339                'color': (0.7, 0.7, 0.7),
 340                'lighting': False,
 341                'color_texture': self.preloaddata['tex'],
 342            },
 343        )
 344        self.background = ba.newnode(
 345            'terrain',
 346            attrs={
 347                'model': self.preloaddata['model_bg'],
 348                'lighting': False,
 349                'background': True,
 350                'color_texture': self.preloaddata['model_bg_tex'],
 351            },
 352        )
 353        ba.newnode(
 354            'terrain',
 355            attrs={
 356                'model': self.preloaddata['bg_vr_fill_model'],
 357                'lighting': False,
 358                'vr_only': True,
 359                'background': True,
 360                'color_texture': self.preloaddata['model_bg_tex'],
 361            },
 362        )
 363        self.railing = ba.newnode(
 364            'terrain',
 365            attrs={
 366                'collide_model': self.preloaddata['bumper_collide_model'],
 367                'materials': [shared.railing_material],
 368                'bumper': True,
 369            },
 370        )
 371        self.bg_collide = ba.newnode(
 372            'terrain',
 373            attrs={
 374                'collide_model': self.preloaddata['collide_bg'],
 375                'materials': [
 376                    shared.footing_material,
 377                    self.preloaddata['bg_material'],
 378                    shared.death_material,
 379                ],
 380            },
 381        )
 382        gnode = ba.getactivity().globalsnode
 383        gnode.tint = (1.1, 1.2, 1.3)
 384        gnode.ambient_color = (1.1, 1.2, 1.3)
 385        gnode.vignette_outer = (0.65, 0.6, 0.55)
 386        gnode.vignette_inner = (0.9, 0.9, 0.93)
 387
 388
 389class Roundabout(ba.Map):
 390    """CTF map featuring two platforms and a long way around between them"""
 391
 392    from bastd.mapdata import roundabout as defs
 393
 394    name = 'Roundabout'
 395
 396    @classmethod
 397    def get_play_types(cls) -> list[str]:
 398        """Return valid play types for this map."""
 399        return ['melee', 'keep_away', 'team_flag']
 400
 401    @classmethod
 402    def get_preview_texture_name(cls) -> str:
 403        return 'roundaboutPreview'
 404
 405    @classmethod
 406    def on_preload(cls) -> Any:
 407        data: dict[str, Any] = {
 408            'model': ba.getmodel('roundaboutLevel'),
 409            'model_bottom': ba.getmodel('roundaboutLevelBottom'),
 410            'model_bg': ba.getmodel('natureBackground'),
 411            'bg_vr_fill_model': ba.getmodel('natureBackgroundVRFill'),
 412            'collide_model': ba.getcollidemodel('roundaboutLevelCollide'),
 413            'tex': ba.gettexture('roundaboutLevelColor'),
 414            'model_bg_tex': ba.gettexture('natureBackgroundColor'),
 415            'collide_bg': ba.getcollidemodel('natureBackgroundCollide'),
 416            'railing_collide_model': (
 417                ba.getcollidemodel('roundaboutLevelBumper')
 418            ),
 419            'bg_material': ba.Material(),
 420        }
 421        data['bg_material'].add_actions(
 422            actions=('modify_part_collision', 'friction', 10.0)
 423        )
 424        return data
 425
 426    def __init__(self) -> None:
 427        super().__init__(vr_overlay_offset=(0, -1, 1))
 428        shared = SharedObjects.get()
 429        self.node = ba.newnode(
 430            'terrain',
 431            delegate=self,
 432            attrs={
 433                'collide_model': self.preloaddata['collide_model'],
 434                'model': self.preloaddata['model'],
 435                'color_texture': self.preloaddata['tex'],
 436                'materials': [shared.footing_material],
 437            },
 438        )
 439        self.bottom = ba.newnode(
 440            'terrain',
 441            attrs={
 442                'model': self.preloaddata['model_bottom'],
 443                'lighting': False,
 444                'color_texture': self.preloaddata['tex'],
 445            },
 446        )
 447        self.background = ba.newnode(
 448            'terrain',
 449            attrs={
 450                'model': self.preloaddata['model_bg'],
 451                'lighting': False,
 452                'background': True,
 453                'color_texture': self.preloaddata['model_bg_tex'],
 454            },
 455        )
 456        ba.newnode(
 457            'terrain',
 458            attrs={
 459                'model': self.preloaddata['bg_vr_fill_model'],
 460                'lighting': False,
 461                'vr_only': True,
 462                'background': True,
 463                'color_texture': self.preloaddata['model_bg_tex'],
 464            },
 465        )
 466        self.bg_collide = ba.newnode(
 467            'terrain',
 468            attrs={
 469                'collide_model': self.preloaddata['collide_bg'],
 470                'materials': [
 471                    shared.footing_material,
 472                    self.preloaddata['bg_material'],
 473                    shared.death_material,
 474                ],
 475            },
 476        )
 477        self.railing = ba.newnode(
 478            'terrain',
 479            attrs={
 480                'collide_model': self.preloaddata['railing_collide_model'],
 481                'materials': [shared.railing_material],
 482                'bumper': True,
 483            },
 484        )
 485        gnode = ba.getactivity().globalsnode
 486        gnode.tint = (1.0, 1.05, 1.1)
 487        gnode.ambient_color = (1.0, 1.05, 1.1)
 488        gnode.shadow_ortho = True
 489        gnode.vignette_outer = (0.63, 0.65, 0.7)
 490        gnode.vignette_inner = (0.97, 0.95, 0.93)
 491
 492
 493class MonkeyFace(ba.Map):
 494    """Map sorta shaped like a monkey face; teehee!"""
 495
 496    from bastd.mapdata import monkey_face as defs
 497
 498    name = 'Monkey Face'
 499
 500    @classmethod
 501    def get_play_types(cls) -> list[str]:
 502        """Return valid play types for this map."""
 503        return ['melee', 'keep_away', 'team_flag']
 504
 505    @classmethod
 506    def get_preview_texture_name(cls) -> str:
 507        return 'monkeyFacePreview'
 508
 509    @classmethod
 510    def on_preload(cls) -> Any:
 511        data: dict[str, Any] = {
 512            'model': ba.getmodel('monkeyFaceLevel'),
 513            'bottom_model': ba.getmodel('monkeyFaceLevelBottom'),
 514            'model_bg': ba.getmodel('natureBackground'),
 515            'bg_vr_fill_model': ba.getmodel('natureBackgroundVRFill'),
 516            'collide_model': ba.getcollidemodel('monkeyFaceLevelCollide'),
 517            'tex': ba.gettexture('monkeyFaceLevelColor'),
 518            'model_bg_tex': ba.gettexture('natureBackgroundColor'),
 519            'collide_bg': ba.getcollidemodel('natureBackgroundCollide'),
 520            'railing_collide_model': (
 521                ba.getcollidemodel('monkeyFaceLevelBumper')
 522            ),
 523            'bg_material': ba.Material(),
 524        }
 525        data['bg_material'].add_actions(
 526            actions=('modify_part_collision', 'friction', 10.0)
 527        )
 528        return data
 529
 530    def __init__(self) -> None:
 531        super().__init__()
 532        shared = SharedObjects.get()
 533        self.node = ba.newnode(
 534            'terrain',
 535            delegate=self,
 536            attrs={
 537                'collide_model': self.preloaddata['collide_model'],
 538                'model': self.preloaddata['model'],
 539                'color_texture': self.preloaddata['tex'],
 540                'materials': [shared.footing_material],
 541            },
 542        )
 543        self.bottom = ba.newnode(
 544            'terrain',
 545            attrs={
 546                'model': self.preloaddata['bottom_model'],
 547                'lighting': False,
 548                'color_texture': self.preloaddata['tex'],
 549            },
 550        )
 551        self.background = ba.newnode(
 552            'terrain',
 553            attrs={
 554                'model': self.preloaddata['model_bg'],
 555                'lighting': False,
 556                'background': True,
 557                'color_texture': self.preloaddata['model_bg_tex'],
 558            },
 559        )
 560        ba.newnode(
 561            'terrain',
 562            attrs={
 563                'model': self.preloaddata['bg_vr_fill_model'],
 564                'lighting': False,
 565                'vr_only': True,
 566                'background': True,
 567                'color_texture': self.preloaddata['model_bg_tex'],
 568            },
 569        )
 570        self.bg_collide = ba.newnode(
 571            'terrain',
 572            attrs={
 573                'collide_model': self.preloaddata['collide_bg'],
 574                'materials': [
 575                    shared.footing_material,
 576                    self.preloaddata['bg_material'],
 577                    shared.death_material,
 578                ],
 579            },
 580        )
 581        self.railing = ba.newnode(
 582            'terrain',
 583            attrs={
 584                'collide_model': self.preloaddata['railing_collide_model'],
 585                'materials': [shared.railing_material],
 586                'bumper': True,
 587            },
 588        )
 589        gnode = ba.getactivity().globalsnode
 590        gnode.tint = (1.1, 1.2, 1.2)
 591        gnode.ambient_color = (1.2, 1.3, 1.3)
 592        gnode.vignette_outer = (0.60, 0.62, 0.66)
 593        gnode.vignette_inner = (0.97, 0.95, 0.93)
 594        gnode.vr_camera_offset = (-1.4, 0, 0)
 595
 596
 597class ZigZag(ba.Map):
 598    """A very long zig-zaggy map"""
 599
 600    from bastd.mapdata import zig_zag as defs
 601
 602    name = 'Zigzag'
 603
 604    @classmethod
 605    def get_play_types(cls) -> list[str]:
 606        """Return valid play types for this map."""
 607        return [
 608            'melee',
 609            'keep_away',
 610            'team_flag',
 611            'conquest',
 612            'king_of_the_hill',
 613        ]
 614
 615    @classmethod
 616    def get_preview_texture_name(cls) -> str:
 617        return 'zigzagPreview'
 618
 619    @classmethod
 620    def on_preload(cls) -> Any:
 621        data: dict[str, Any] = {
 622            'model': ba.getmodel('zigZagLevel'),
 623            'model_bottom': ba.getmodel('zigZagLevelBottom'),
 624            'model_bg': ba.getmodel('natureBackground'),
 625            'bg_vr_fill_model': ba.getmodel('natureBackgroundVRFill'),
 626            'collide_model': ba.getcollidemodel('zigZagLevelCollide'),
 627            'tex': ba.gettexture('zigZagLevelColor'),
 628            'model_bg_tex': ba.gettexture('natureBackgroundColor'),
 629            'collide_bg': ba.getcollidemodel('natureBackgroundCollide'),
 630            'railing_collide_model': ba.getcollidemodel('zigZagLevelBumper'),
 631            'bg_material': ba.Material(),
 632        }
 633        data['bg_material'].add_actions(
 634            actions=('modify_part_collision', 'friction', 10.0)
 635        )
 636        return data
 637
 638    def __init__(self) -> None:
 639        super().__init__()
 640        shared = SharedObjects.get()
 641        self.node = ba.newnode(
 642            'terrain',
 643            delegate=self,
 644            attrs={
 645                'collide_model': self.preloaddata['collide_model'],
 646                'model': self.preloaddata['model'],
 647                'color_texture': self.preloaddata['tex'],
 648                'materials': [shared.footing_material],
 649            },
 650        )
 651        self.background = ba.newnode(
 652            'terrain',
 653            attrs={
 654                'model': self.preloaddata['model_bg'],
 655                'lighting': False,
 656                'color_texture': self.preloaddata['model_bg_tex'],
 657            },
 658        )
 659        self.bottom = ba.newnode(
 660            'terrain',
 661            attrs={
 662                'model': self.preloaddata['model_bottom'],
 663                'lighting': False,
 664                'color_texture': self.preloaddata['tex'],
 665            },
 666        )
 667        ba.newnode(
 668            'terrain',
 669            attrs={
 670                'model': self.preloaddata['bg_vr_fill_model'],
 671                'lighting': False,
 672                'vr_only': True,
 673                'background': True,
 674                'color_texture': self.preloaddata['model_bg_tex'],
 675            },
 676        )
 677        self.bg_collide = ba.newnode(
 678            'terrain',
 679            attrs={
 680                'collide_model': self.preloaddata['collide_bg'],
 681                'materials': [
 682                    shared.footing_material,
 683                    self.preloaddata['bg_material'],
 684                    shared.death_material,
 685                ],
 686            },
 687        )
 688        self.railing = ba.newnode(
 689            'terrain',
 690            attrs={
 691                'collide_model': self.preloaddata['railing_collide_model'],
 692                'materials': [shared.railing_material],
 693                'bumper': True,
 694            },
 695        )
 696        gnode = ba.getactivity().globalsnode
 697        gnode.tint = (1.0, 1.15, 1.15)
 698        gnode.ambient_color = (1.0, 1.15, 1.15)
 699        gnode.vignette_outer = (0.57, 0.59, 0.63)
 700        gnode.vignette_inner = (0.97, 0.95, 0.93)
 701        gnode.vr_camera_offset = (-1.5, 0, 0)
 702
 703
 704class ThePad(ba.Map):
 705    """A simple square shaped map with a raised edge."""
 706
 707    from bastd.mapdata import the_pad as defs
 708
 709    name = 'The Pad'
 710
 711    @classmethod
 712    def get_play_types(cls) -> list[str]:
 713        """Return valid play types for this map."""
 714        return ['melee', 'keep_away', 'team_flag', 'king_of_the_hill']
 715
 716    @classmethod
 717    def get_preview_texture_name(cls) -> str:
 718        return 'thePadPreview'
 719
 720    @classmethod
 721    def on_preload(cls) -> Any:
 722        data: dict[str, Any] = {
 723            'model': ba.getmodel('thePadLevel'),
 724            'bottom_model': ba.getmodel('thePadLevelBottom'),
 725            'collide_model': ba.getcollidemodel('thePadLevelCollide'),
 726            'tex': ba.gettexture('thePadLevelColor'),
 727            'bgtex': ba.gettexture('menuBG'),
 728            'bgmodel': ba.getmodel('thePadBG'),
 729            'railing_collide_model': ba.getcollidemodel('thePadLevelBumper'),
 730            'vr_fill_mound_model': ba.getmodel('thePadVRFillMound'),
 731            'vr_fill_mound_tex': ba.gettexture('vrFillMound'),
 732        }
 733        # fixme should chop this into vr/non-vr sections for efficiency
 734        return data
 735
 736    def __init__(self) -> None:
 737        super().__init__()
 738        shared = SharedObjects.get()
 739        self.node = ba.newnode(
 740            'terrain',
 741            delegate=self,
 742            attrs={
 743                'collide_model': self.preloaddata['collide_model'],
 744                'model': self.preloaddata['model'],
 745                'color_texture': self.preloaddata['tex'],
 746                'materials': [shared.footing_material],
 747            },
 748        )
 749        self.bottom = ba.newnode(
 750            'terrain',
 751            attrs={
 752                'model': self.preloaddata['bottom_model'],
 753                'lighting': False,
 754                'color_texture': self.preloaddata['tex'],
 755            },
 756        )
 757        self.background = ba.newnode(
 758            'terrain',
 759            attrs={
 760                'model': self.preloaddata['bgmodel'],
 761                'lighting': False,
 762                'background': True,
 763                'color_texture': self.preloaddata['bgtex'],
 764            },
 765        )
 766        self.railing = ba.newnode(
 767            'terrain',
 768            attrs={
 769                'collide_model': self.preloaddata['railing_collide_model'],
 770                'materials': [shared.railing_material],
 771                'bumper': True,
 772            },
 773        )
 774        ba.newnode(
 775            'terrain',
 776            attrs={
 777                'model': self.preloaddata['vr_fill_mound_model'],
 778                'lighting': False,
 779                'vr_only': True,
 780                'color': (0.56, 0.55, 0.47),
 781                'background': True,
 782                'color_texture': self.preloaddata['vr_fill_mound_tex'],
 783            },
 784        )
 785        gnode = ba.getactivity().globalsnode
 786        gnode.tint = (1.1, 1.1, 1.0)
 787        gnode.ambient_color = (1.1, 1.1, 1.0)
 788        gnode.vignette_outer = (0.7, 0.65, 0.75)
 789        gnode.vignette_inner = (0.95, 0.95, 0.93)
 790
 791
 792class DoomShroom(ba.Map):
 793    """A giant mushroom. Of doom!"""
 794
 795    from bastd.mapdata import doom_shroom as defs
 796
 797    name = 'Doom Shroom'
 798
 799    @classmethod
 800    def get_play_types(cls) -> list[str]:
 801        """Return valid play types for this map."""
 802        return ['melee', 'keep_away', 'team_flag']
 803
 804    @classmethod
 805    def get_preview_texture_name(cls) -> str:
 806        return 'doomShroomPreview'
 807
 808    @classmethod
 809    def on_preload(cls) -> Any:
 810        data: dict[str, Any] = {
 811            'model': ba.getmodel('doomShroomLevel'),
 812            'collide_model': ba.getcollidemodel('doomShroomLevelCollide'),
 813            'tex': ba.gettexture('doomShroomLevelColor'),
 814            'bgtex': ba.gettexture('doomShroomBGColor'),
 815            'bgmodel': ba.getmodel('doomShroomBG'),
 816            'vr_fill_model': ba.getmodel('doomShroomVRFill'),
 817            'stem_model': ba.getmodel('doomShroomStem'),
 818            'collide_bg': ba.getcollidemodel('doomShroomStemCollide'),
 819        }
 820        return data
 821
 822    def __init__(self) -> None:
 823        super().__init__()
 824        shared = SharedObjects.get()
 825        self.node = ba.newnode(
 826            'terrain',
 827            delegate=self,
 828            attrs={
 829                'collide_model': self.preloaddata['collide_model'],
 830                'model': self.preloaddata['model'],
 831                'color_texture': self.preloaddata['tex'],
 832                'materials': [shared.footing_material],
 833            },
 834        )
 835        self.background = ba.newnode(
 836            'terrain',
 837            attrs={
 838                'model': self.preloaddata['bgmodel'],
 839                'lighting': False,
 840                'background': True,
 841                'color_texture': self.preloaddata['bgtex'],
 842            },
 843        )
 844        ba.newnode(
 845            'terrain',
 846            attrs={
 847                'model': self.preloaddata['vr_fill_model'],
 848                'lighting': False,
 849                'vr_only': True,
 850                'background': True,
 851                'color_texture': self.preloaddata['bgtex'],
 852            },
 853        )
 854        self.stem = ba.newnode(
 855            'terrain',
 856            attrs={
 857                'model': self.preloaddata['stem_model'],
 858                'lighting': False,
 859                'color_texture': self.preloaddata['tex'],
 860            },
 861        )
 862        self.bg_collide = ba.newnode(
 863            'terrain',
 864            attrs={
 865                'collide_model': self.preloaddata['collide_bg'],
 866                'materials': [shared.footing_material, shared.death_material],
 867            },
 868        )
 869        gnode = ba.getactivity().globalsnode
 870        gnode.tint = (0.82, 1.10, 1.15)
 871        gnode.ambient_color = (0.9, 1.3, 1.1)
 872        gnode.shadow_ortho = False
 873        gnode.vignette_outer = (0.76, 0.76, 0.76)
 874        gnode.vignette_inner = (0.95, 0.95, 0.99)
 875
 876    def is_point_near_edge(self, point: ba.Vec3, running: bool = False) -> bool:
 877        xpos = point.x
 878        zpos = point.z
 879        x_adj = xpos * 0.125
 880        z_adj = (zpos + 3.7) * 0.2
 881        if running:
 882            x_adj *= 1.4
 883            z_adj *= 1.4
 884        return x_adj * x_adj + z_adj * z_adj > 1.0
 885
 886
 887class LakeFrigid(ba.Map):
 888    """An icy lake fit for racing."""
 889
 890    from bastd.mapdata import lake_frigid as defs
 891
 892    name = 'Lake Frigid'
 893
 894    @classmethod
 895    def get_play_types(cls) -> list[str]:
 896        """Return valid play types for this map."""
 897        return ['melee', 'keep_away', 'team_flag', 'race']
 898
 899    @classmethod
 900    def get_preview_texture_name(cls) -> str:
 901        return 'lakeFrigidPreview'
 902
 903    @classmethod
 904    def on_preload(cls) -> Any:
 905        data: dict[str, Any] = {
 906            'model': ba.getmodel('lakeFrigid'),
 907            'model_top': ba.getmodel('lakeFrigidTop'),
 908            'model_reflections': ba.getmodel('lakeFrigidReflections'),
 909            'collide_model': ba.getcollidemodel('lakeFrigidCollide'),
 910            'tex': ba.gettexture('lakeFrigid'),
 911            'tex_reflections': ba.gettexture('lakeFrigidReflections'),
 912            'vr_fill_model': ba.getmodel('lakeFrigidVRFill'),
 913        }
 914        mat = ba.Material()
 915        mat.add_actions(actions=('modify_part_collision', 'friction', 0.01))
 916        data['ice_material'] = mat
 917        return data
 918
 919    def __init__(self) -> None:
 920        super().__init__()
 921        shared = SharedObjects.get()
 922        self.node = ba.newnode(
 923            'terrain',
 924            delegate=self,
 925            attrs={
 926                'collide_model': self.preloaddata['collide_model'],
 927                'model': self.preloaddata['model'],
 928                'color_texture': self.preloaddata['tex'],
 929                'materials': [
 930                    shared.footing_material,
 931                    self.preloaddata['ice_material'],
 932                ],
 933            },
 934        )
 935        ba.newnode(
 936            'terrain',
 937            attrs={
 938                'model': self.preloaddata['model_top'],
 939                'lighting': False,
 940                'color_texture': self.preloaddata['tex'],
 941            },
 942        )
 943        ba.newnode(
 944            'terrain',
 945            attrs={
 946                'model': self.preloaddata['model_reflections'],
 947                'lighting': False,
 948                'overlay': True,
 949                'opacity': 0.15,
 950                'color_texture': self.preloaddata['tex_reflections'],
 951            },
 952        )
 953        ba.newnode(
 954            'terrain',
 955            attrs={
 956                'model': self.preloaddata['vr_fill_model'],
 957                'lighting': False,
 958                'vr_only': True,
 959                'background': True,
 960                'color_texture': self.preloaddata['tex'],
 961            },
 962        )
 963        gnode = ba.getactivity().globalsnode
 964        gnode.tint = (1, 1, 1)
 965        gnode.ambient_color = (1, 1, 1)
 966        gnode.shadow_ortho = True
 967        gnode.vignette_outer = (0.86, 0.86, 0.86)
 968        gnode.vignette_inner = (0.95, 0.95, 0.99)
 969        gnode.vr_near_clip = 0.5
 970        self.is_hockey = True
 971
 972
 973class TipTop(ba.Map):
 974    """A pointy map good for king-of-the-hill-ish games."""
 975
 976    from bastd.mapdata import tip_top as defs
 977
 978    name = 'Tip Top'
 979
 980    @classmethod
 981    def get_play_types(cls) -> list[str]:
 982        """Return valid play types for this map."""
 983        return ['melee', 'keep_away', 'team_flag', 'king_of_the_hill']
 984
 985    @classmethod
 986    def get_preview_texture_name(cls) -> str:
 987        return 'tipTopPreview'
 988
 989    @classmethod
 990    def on_preload(cls) -> Any:
 991        data: dict[str, Any] = {
 992            'model': ba.getmodel('tipTopLevel'),
 993            'bottom_model': ba.getmodel('tipTopLevelBottom'),
 994            'collide_model': ba.getcollidemodel('tipTopLevelCollide'),
 995            'tex': ba.gettexture('tipTopLevelColor'),
 996            'bgtex': ba.gettexture('tipTopBGColor'),
 997            'bgmodel': ba.getmodel('tipTopBG'),
 998            'railing_collide_model': ba.getcollidemodel('tipTopLevelBumper'),
 999        }
1000        return data
1001
1002    def __init__(self) -> None:
1003        super().__init__(vr_overlay_offset=(0, -0.2, 2.5))
1004        shared = SharedObjects.get()
1005        self.node = ba.newnode(
1006            'terrain',
1007            delegate=self,
1008            attrs={
1009                'collide_model': self.preloaddata['collide_model'],
1010                'model': self.preloaddata['model'],
1011                'color_texture': self.preloaddata['tex'],
1012                'color': (0.7, 0.7, 0.7),
1013                'materials': [shared.footing_material],
1014            },
1015        )
1016        self.bottom = ba.newnode(
1017            'terrain',
1018            attrs={
1019                'model': self.preloaddata['bottom_model'],
1020                'lighting': False,
1021                'color': (0.7, 0.7, 0.7),
1022                'color_texture': self.preloaddata['tex'],
1023            },
1024        )
1025        self.background = ba.newnode(
1026            'terrain',
1027            attrs={
1028                'model': self.preloaddata['bgmodel'],
1029                'lighting': False,
1030                'color': (0.4, 0.4, 0.4),
1031                'background': True,
1032                'color_texture': self.preloaddata['bgtex'],
1033            },
1034        )
1035        self.railing = ba.newnode(
1036            'terrain',
1037            attrs={
1038                'collide_model': self.preloaddata['railing_collide_model'],
1039                'materials': [shared.railing_material],
1040                'bumper': True,
1041            },
1042        )
1043        gnode = ba.getactivity().globalsnode
1044        gnode.tint = (0.8, 0.9, 1.3)
1045        gnode.ambient_color = (0.8, 0.9, 1.3)
1046        gnode.vignette_outer = (0.79, 0.79, 0.69)
1047        gnode.vignette_inner = (0.97, 0.97, 0.99)
1048
1049
1050class CragCastle(ba.Map):
1051    """A lovely castle map."""
1052
1053    from bastd.mapdata import crag_castle as defs
1054
1055    name = 'Crag Castle'
1056
1057    @classmethod
1058    def get_play_types(cls) -> list[str]:
1059        """Return valid play types for this map."""
1060        return ['melee', 'keep_away', 'team_flag', 'conquest']
1061
1062    @classmethod
1063    def get_preview_texture_name(cls) -> str:
1064        return 'cragCastlePreview'
1065
1066    @classmethod
1067    def on_preload(cls) -> Any:
1068        data: dict[str, Any] = {
1069            'model': ba.getmodel('cragCastleLevel'),
1070            'bottom_model': ba.getmodel('cragCastleLevelBottom'),
1071            'collide_model': ba.getcollidemodel('cragCastleLevelCollide'),
1072            'tex': ba.gettexture('cragCastleLevelColor'),
1073            'bgtex': ba.gettexture('menuBG'),
1074            'bgmodel': ba.getmodel('thePadBG'),
1075            'railing_collide_model': (
1076                ba.getcollidemodel('cragCastleLevelBumper')
1077            ),
1078            'vr_fill_mound_model': ba.getmodel('cragCastleVRFillMound'),
1079            'vr_fill_mound_tex': ba.gettexture('vrFillMound'),
1080        }
1081        # fixme should chop this into vr/non-vr sections
1082        return data
1083
1084    def __init__(self) -> None:
1085        super().__init__()
1086        shared = SharedObjects.get()
1087        self.node = ba.newnode(
1088            'terrain',
1089            delegate=self,
1090            attrs={
1091                'collide_model': self.preloaddata['collide_model'],
1092                'model': self.preloaddata['model'],
1093                'color_texture': self.preloaddata['tex'],
1094                'materials': [shared.footing_material],
1095            },
1096        )
1097        self.bottom = ba.newnode(
1098            'terrain',
1099            attrs={
1100                'model': self.preloaddata['bottom_model'],
1101                'lighting': False,
1102                'color_texture': self.preloaddata['tex'],
1103            },
1104        )
1105        self.background = ba.newnode(
1106            'terrain',
1107            attrs={
1108                'model': self.preloaddata['bgmodel'],
1109                'lighting': False,
1110                'background': True,
1111                'color_texture': self.preloaddata['bgtex'],
1112            },
1113        )
1114        self.railing = ba.newnode(
1115            'terrain',
1116            attrs={
1117                'collide_model': self.preloaddata['railing_collide_model'],
1118                'materials': [shared.railing_material],
1119                'bumper': True,
1120            },
1121        )
1122        ba.newnode(
1123            'terrain',
1124            attrs={
1125                'model': self.preloaddata['vr_fill_mound_model'],
1126                'lighting': False,
1127                'vr_only': True,
1128                'color': (0.2, 0.25, 0.2),
1129                'background': True,
1130                'color_texture': self.preloaddata['vr_fill_mound_tex'],
1131            },
1132        )
1133        gnode = ba.getactivity().globalsnode
1134        gnode.shadow_ortho = True
1135        gnode.shadow_offset = (0, 0, -5.0)
1136        gnode.tint = (1.15, 1.05, 0.75)
1137        gnode.ambient_color = (1.15, 1.05, 0.75)
1138        gnode.vignette_outer = (0.6, 0.65, 0.6)
1139        gnode.vignette_inner = (0.95, 0.95, 0.95)
1140        gnode.vr_near_clip = 1.0
1141
1142
1143class TowerD(ba.Map):
1144    """Map used for runaround mini-game."""
1145
1146    from bastd.mapdata import tower_d as defs
1147
1148    name = 'Tower D'
1149
1150    @classmethod
1151    def get_play_types(cls) -> list[str]:
1152        """Return valid play types for this map."""
1153        return []
1154
1155    @classmethod
1156    def get_preview_texture_name(cls) -> str:
1157        return 'towerDPreview'
1158
1159    @classmethod
1160    def on_preload(cls) -> Any:
1161        data: dict[str, Any] = {
1162            'model': ba.getmodel('towerDLevel'),
1163            'model_bottom': ba.getmodel('towerDLevelBottom'),
1164            'collide_model': ba.getcollidemodel('towerDLevelCollide'),
1165            'tex': ba.gettexture('towerDLevelColor'),
1166            'bgtex': ba.gettexture('menuBG'),
1167            'bgmodel': ba.getmodel('thePadBG'),
1168            'player_wall_collide_model': ba.getcollidemodel('towerDPlayerWall'),
1169            'player_wall_material': ba.Material(),
1170        }
1171        # fixme should chop this into vr/non-vr sections
1172        data['player_wall_material'].add_actions(
1173            actions=('modify_part_collision', 'friction', 0.0)
1174        )
1175        # anything that needs to hit the wall can apply this material
1176        data['collide_with_wall_material'] = ba.Material()
1177        data['player_wall_material'].add_actions(
1178            conditions=(
1179                'they_dont_have_material',
1180                data['collide_with_wall_material'],
1181            ),
1182            actions=('modify_part_collision', 'collide', False),
1183        )
1184        data['vr_fill_mound_model'] = ba.getmodel('stepRightUpVRFillMound')
1185        data['vr_fill_mound_tex'] = ba.gettexture('vrFillMound')
1186        return data
1187
1188    def __init__(self) -> None:
1189        super().__init__(vr_overlay_offset=(0, 1, 1))
1190        shared = SharedObjects.get()
1191        self.node = ba.newnode(
1192            'terrain',
1193            delegate=self,
1194            attrs={
1195                'collide_model': self.preloaddata['collide_model'],
1196                'model': self.preloaddata['model'],
1197                'color_texture': self.preloaddata['tex'],
1198                'materials': [shared.footing_material],
1199            },
1200        )
1201        self.node_bottom = ba.newnode(
1202            'terrain',
1203            delegate=self,
1204            attrs={
1205                'model': self.preloaddata['model_bottom'],
1206                'lighting': False,
1207                'color_texture': self.preloaddata['tex'],
1208            },
1209        )
1210        ba.newnode(
1211            'terrain',
1212            attrs={
1213                'model': self.preloaddata['vr_fill_mound_model'],
1214                'lighting': False,
1215                'vr_only': True,
1216                'color': (0.53, 0.57, 0.5),
1217                'background': True,
1218                'color_texture': self.preloaddata['vr_fill_mound_tex'],
1219            },
1220        )
1221        self.background = ba.newnode(
1222            'terrain',
1223            attrs={
1224                'model': self.preloaddata['bgmodel'],
1225                'lighting': False,
1226                'background': True,
1227                'color_texture': self.preloaddata['bgtex'],
1228            },
1229        )
1230        self.player_wall = ba.newnode(
1231            'terrain',
1232            attrs={
1233                'collide_model': self.preloaddata['player_wall_collide_model'],
1234                'affect_bg_dynamics': False,
1235                'materials': [self.preloaddata['player_wall_material']],
1236            },
1237        )
1238        gnode = ba.getactivity().globalsnode
1239        gnode.tint = (1.15, 1.11, 1.03)
1240        gnode.ambient_color = (1.2, 1.1, 1.0)
1241        gnode.vignette_outer = (0.7, 0.73, 0.7)
1242        gnode.vignette_inner = (0.95, 0.95, 0.95)
1243
1244    def is_point_near_edge(self, point: ba.Vec3, running: bool = False) -> bool:
1245        # see if we're within edge_box
1246        boxes = self.defs.boxes
1247        box_position = boxes['edge_box'][0:3]
1248        box_scale = boxes['edge_box'][6:9]
1249        box_position2 = boxes['edge_box2'][0:3]
1250        box_scale2 = boxes['edge_box2'][6:9]
1251        xpos = (point.x - box_position[0]) / box_scale[0]
1252        zpos = (point.z - box_position[2]) / box_scale[2]
1253        xpos2 = (point.x - box_position2[0]) / box_scale2[0]
1254        zpos2 = (point.z - box_position2[2]) / box_scale2[2]
1255        # if we're outside of *both* boxes we're near the edge
1256        return (xpos < -0.5 or xpos > 0.5 or zpos < -0.5 or zpos > 0.5) and (
1257            xpos2 < -0.5 or xpos2 > 0.5 or zpos2 < -0.5 or zpos2 > 0.5
1258        )
1259
1260
1261class HappyThoughts(ba.Map):
1262    """Flying map."""
1263
1264    from bastd.mapdata import happy_thoughts as defs
1265
1266    name = 'Happy Thoughts'
1267
1268    @classmethod
1269    def get_play_types(cls) -> list[str]:
1270        """Return valid play types for this map."""
1271        return [
1272            'melee',
1273            'keep_away',
1274            'team_flag',
1275            'conquest',
1276            'king_of_the_hill',
1277        ]
1278
1279    @classmethod
1280    def get_preview_texture_name(cls) -> str:
1281        return 'alwaysLandPreview'
1282
1283    @classmethod
1284    def on_preload(cls) -> Any:
1285        data: dict[str, Any] = {
1286            'model': ba.getmodel('alwaysLandLevel'),
1287            'bottom_model': ba.getmodel('alwaysLandLevelBottom'),
1288            'bgmodel': ba.getmodel('alwaysLandBG'),
1289            'collide_model': ba.getcollidemodel('alwaysLandLevelCollide'),
1290            'tex': ba.gettexture('alwaysLandLevelColor'),
1291            'bgtex': ba.gettexture('alwaysLandBGColor'),
1292            'vr_fill_mound_model': ba.getmodel('alwaysLandVRFillMound'),
1293            'vr_fill_mound_tex': ba.gettexture('vrFillMound'),
1294        }
1295        return data
1296
1297    @classmethod
1298    def get_music_type(cls) -> ba.MusicType:
1299        return ba.MusicType.FLYING
1300
1301    def __init__(self) -> None:
1302        super().__init__(vr_overlay_offset=(0, -3.7, 2.5))
1303        shared = SharedObjects.get()
1304        self.node = ba.newnode(
1305            'terrain',
1306            delegate=self,
1307            attrs={
1308                'collide_model': self.preloaddata['collide_model'],
1309                'model': self.preloaddata['model'],
1310                'color_texture': self.preloaddata['tex'],
1311                'materials': [shared.footing_material],
1312            },
1313        )
1314        self.bottom = ba.newnode(
1315            'terrain',
1316            attrs={
1317                'model': self.preloaddata['bottom_model'],
1318                'lighting': False,
1319                'color_texture': self.preloaddata['tex'],
1320            },
1321        )
1322        self.background = ba.newnode(
1323            'terrain',
1324            attrs={
1325                'model': self.preloaddata['bgmodel'],
1326                'lighting': False,
1327                'background': True,
1328                'color_texture': self.preloaddata['bgtex'],
1329            },
1330        )
1331        ba.newnode(
1332            'terrain',
1333            attrs={
1334                'model': self.preloaddata['vr_fill_mound_model'],
1335                'lighting': False,
1336                'vr_only': True,
1337                'color': (0.2, 0.25, 0.2),
1338                'background': True,
1339                'color_texture': self.preloaddata['vr_fill_mound_tex'],
1340            },
1341        )
1342        gnode = ba.getactivity().globalsnode
1343        gnode.happy_thoughts_mode = True
1344        gnode.shadow_offset = (0.0, 8.0, 5.0)
1345        gnode.tint = (1.3, 1.23, 1.0)
1346        gnode.ambient_color = (1.3, 1.23, 1.0)
1347        gnode.vignette_outer = (0.64, 0.59, 0.69)
1348        gnode.vignette_inner = (0.95, 0.95, 0.93)
1349        gnode.vr_near_clip = 1.0
1350        self.is_flying = True
1351
1352        # throw out some tips on flying
1353        txt = ba.newnode(
1354            'text',
1355            attrs={
1356                'text': ba.Lstr(resource='pressJumpToFlyText'),
1357                'scale': 1.2,
1358                'maxwidth': 800,
1359                'position': (0, 200),
1360                'shadow': 0.5,
1361                'flatness': 0.5,
1362                'h_align': 'center',
1363                'v_attach': 'bottom',
1364            },
1365        )
1366        cmb = ba.newnode(
1367            'combine',
1368            owner=txt,
1369            attrs={'size': 4, 'input0': 0.3, 'input1': 0.9, 'input2': 0.0},
1370        )
1371        ba.animate(cmb, 'input3', {3.0: 0, 4.0: 1, 9.0: 1, 10.0: 0})
1372        cmb.connectattr('output', txt, 'color')
1373        ba.timer(10.0, txt.delete)
1374
1375
1376class StepRightUp(ba.Map):
1377    """Wide stepped map good for CTF or Assault."""
1378
1379    from bastd.mapdata import step_right_up as defs
1380
1381    name = 'Step Right Up'
1382
1383    @classmethod
1384    def get_play_types(cls) -> list[str]:
1385        """Return valid play types for this map."""
1386        return ['melee', 'keep_away', 'team_flag', 'conquest']
1387
1388    @classmethod
1389    def get_preview_texture_name(cls) -> str:
1390        return 'stepRightUpPreview'
1391
1392    @classmethod
1393    def on_preload(cls) -> Any:
1394        data: dict[str, Any] = {
1395            'model': ba.getmodel('stepRightUpLevel'),
1396            'model_bottom': ba.getmodel('stepRightUpLevelBottom'),
1397            'collide_model': ba.getcollidemodel('stepRightUpLevelCollide'),
1398            'tex': ba.gettexture('stepRightUpLevelColor'),
1399            'bgtex': ba.gettexture('menuBG'),
1400            'bgmodel': ba.getmodel('thePadBG'),
1401            'vr_fill_mound_model': ba.getmodel('stepRightUpVRFillMound'),
1402            'vr_fill_mound_tex': ba.gettexture('vrFillMound'),
1403        }
1404        # fixme should chop this into vr/non-vr chunks
1405        return data
1406
1407    def __init__(self) -> None:
1408        super().__init__(vr_overlay_offset=(0, -1, 2))
1409        shared = SharedObjects.get()
1410        self.node = ba.newnode(
1411            'terrain',
1412            delegate=self,
1413            attrs={
1414                'collide_model': self.preloaddata['collide_model'],
1415                'model': self.preloaddata['model'],
1416                'color_texture': self.preloaddata['tex'],
1417                'materials': [shared.footing_material],
1418            },
1419        )
1420        self.node_bottom = ba.newnode(
1421            'terrain',
1422            delegate=self,
1423            attrs={
1424                'model': self.preloaddata['model_bottom'],
1425                'lighting': False,
1426                'color_texture': self.preloaddata['tex'],
1427            },
1428        )
1429        ba.newnode(
1430            'terrain',
1431            attrs={
1432                'model': self.preloaddata['vr_fill_mound_model'],
1433                'lighting': False,
1434                'vr_only': True,
1435                'color': (0.53, 0.57, 0.5),
1436                'background': True,
1437                'color_texture': self.preloaddata['vr_fill_mound_tex'],
1438            },
1439        )
1440        self.background = ba.newnode(
1441            'terrain',
1442            attrs={
1443                'model': self.preloaddata['bgmodel'],
1444                'lighting': False,
1445                'background': True,
1446                'color_texture': self.preloaddata['bgtex'],
1447            },
1448        )
1449        gnode = ba.getactivity().globalsnode
1450        gnode.tint = (1.2, 1.1, 1.0)
1451        gnode.ambient_color = (1.2, 1.1, 1.0)
1452        gnode.vignette_outer = (0.7, 0.65, 0.75)
1453        gnode.vignette_inner = (0.95, 0.95, 0.93)
1454
1455
1456class Courtyard(ba.Map):
1457    """A courtyard-ish looking map for co-op levels."""
1458
1459    from bastd.mapdata import courtyard as defs
1460
1461    name = 'Courtyard'
1462
1463    @classmethod
1464    def get_play_types(cls) -> list[str]:
1465        """Return valid play types for this map."""
1466        return ['melee', 'keep_away', 'team_flag']
1467
1468    @classmethod
1469    def get_preview_texture_name(cls) -> str:
1470        return 'courtyardPreview'
1471
1472    @classmethod
1473    def on_preload(cls) -> Any:
1474        data: dict[str, Any] = {
1475            'model': ba.getmodel('courtyardLevel'),
1476            'model_bottom': ba.getmodel('courtyardLevelBottom'),
1477            'collide_model': ba.getcollidemodel('courtyardLevelCollide'),
1478            'tex': ba.gettexture('courtyardLevelColor'),
1479            'bgtex': ba.gettexture('menuBG'),
1480            'bgmodel': ba.getmodel('thePadBG'),
1481            'player_wall_collide_model': (
1482                ba.getcollidemodel('courtyardPlayerWall')
1483            ),
1484            'player_wall_material': ba.Material(),
1485        }
1486        # FIXME: Chop this into vr and non-vr chunks.
1487        data['player_wall_material'].add_actions(
1488            actions=('modify_part_collision', 'friction', 0.0)
1489        )
1490        # anything that needs to hit the wall should apply this.
1491        data['collide_with_wall_material'] = ba.Material()
1492        data['player_wall_material'].add_actions(
1493            conditions=(
1494                'they_dont_have_material',
1495                data['collide_with_wall_material'],
1496            ),
1497            actions=('modify_part_collision', 'collide', False),
1498        )
1499        data['vr_fill_mound_model'] = ba.getmodel('stepRightUpVRFillMound')
1500        data['vr_fill_mound_tex'] = ba.gettexture('vrFillMound')
1501        return data
1502
1503    def __init__(self) -> None:
1504        super().__init__()
1505        shared = SharedObjects.get()
1506        self.node = ba.newnode(
1507            'terrain',
1508            delegate=self,
1509            attrs={
1510                'collide_model': self.preloaddata['collide_model'],
1511                'model': self.preloaddata['model'],
1512                'color_texture': self.preloaddata['tex'],
1513                'materials': [shared.footing_material],
1514            },
1515        )
1516        self.background = ba.newnode(
1517            'terrain',
1518            attrs={
1519                'model': self.preloaddata['bgmodel'],
1520                'lighting': False,
1521                'background': True,
1522                'color_texture': self.preloaddata['bgtex'],
1523            },
1524        )
1525        self.bottom = ba.newnode(
1526            'terrain',
1527            attrs={
1528                'model': self.preloaddata['model_bottom'],
1529                'lighting': False,
1530                'color_texture': self.preloaddata['tex'],
1531            },
1532        )
1533        ba.newnode(
1534            'terrain',
1535            attrs={
1536                'model': self.preloaddata['vr_fill_mound_model'],
1537                'lighting': False,
1538                'vr_only': True,
1539                'color': (0.53, 0.57, 0.5),
1540                'background': True,
1541                'color_texture': self.preloaddata['vr_fill_mound_tex'],
1542            },
1543        )
1544        # in co-op mode games, put up a wall to prevent players
1545        # from getting in the turrets (that would foil our brilliant AI)
1546        if isinstance(ba.getsession(), ba.CoopSession):
1547            cmodel = self.preloaddata['player_wall_collide_model']
1548            self.player_wall = ba.newnode(
1549                'terrain',
1550                attrs={
1551                    'collide_model': cmodel,
1552                    'affect_bg_dynamics': False,
1553                    'materials': [self.preloaddata['player_wall_material']],
1554                },
1555            )
1556        gnode = ba.getactivity().globalsnode
1557        gnode.tint = (1.2, 1.17, 1.1)
1558        gnode.ambient_color = (1.2, 1.17, 1.1)
1559        gnode.vignette_outer = (0.6, 0.6, 0.64)
1560        gnode.vignette_inner = (0.95, 0.95, 0.93)
1561
1562    def is_point_near_edge(self, point: ba.Vec3, running: bool = False) -> bool:
1563        # count anything off our ground level as safe (for our platforms)
1564        # see if we're within edge_box
1565        box_position = self.defs.boxes['edge_box'][0:3]
1566        box_scale = self.defs.boxes['edge_box'][6:9]
1567        xpos = (point.x - box_position[0]) / box_scale[0]
1568        zpos = (point.z - box_position[2]) / box_scale[2]
1569        return xpos < -0.5 or xpos > 0.5 or zpos < -0.5 or zpos > 0.5
1570
1571
1572class Rampage(ba.Map):
1573    """Wee little map with ramps on the sides."""
1574
1575    from bastd.mapdata import rampage as defs
1576
1577    name = 'Rampage'
1578
1579    @classmethod
1580    def get_play_types(cls) -> list[str]:
1581        """Return valid play types for this map."""
1582        return ['melee', 'keep_away', 'team_flag']
1583
1584    @classmethod
1585    def get_preview_texture_name(cls) -> str:
1586        return 'rampagePreview'
1587
1588    @classmethod
1589    def on_preload(cls) -> Any:
1590        data: dict[str, Any] = {
1591            'model': ba.getmodel('rampageLevel'),
1592            'bottom_model': ba.getmodel('rampageLevelBottom'),
1593            'collide_model': ba.getcollidemodel('rampageLevelCollide'),
1594            'tex': ba.gettexture('rampageLevelColor'),
1595            'bgtex': ba.gettexture('rampageBGColor'),
1596            'bgtex2': ba.gettexture('rampageBGColor2'),
1597            'bgmodel': ba.getmodel('rampageBG'),
1598            'bgmodel2': ba.getmodel('rampageBG2'),
1599            'vr_fill_model': ba.getmodel('rampageVRFill'),
1600            'railing_collide_model': ba.getcollidemodel('rampageBumper'),
1601        }
1602        return data
1603
1604    def __init__(self) -> None:
1605        super().__init__(vr_overlay_offset=(0, 0, 2))
1606        shared = SharedObjects.get()
1607        self.node = ba.newnode(
1608            'terrain',
1609            delegate=self,
1610            attrs={
1611                'collide_model': self.preloaddata['collide_model'],
1612                'model': self.preloaddata['model'],
1613                'color_texture': self.preloaddata['tex'],
1614                'materials': [shared.footing_material],
1615            },
1616        )
1617        self.background = ba.newnode(
1618            'terrain',
1619            attrs={
1620                'model': self.preloaddata['bgmodel'],
1621                'lighting': False,
1622                'background': True,
1623                'color_texture': self.preloaddata['bgtex'],
1624            },
1625        )
1626        self.bottom = ba.newnode(
1627            'terrain',
1628            attrs={
1629                'model': self.preloaddata['bottom_model'],
1630                'lighting': False,
1631                'color_texture': self.preloaddata['tex'],
1632            },
1633        )
1634        self.bg2 = ba.newnode(
1635            'terrain',
1636            attrs={
1637                'model': self.preloaddata['bgmodel2'],
1638                'lighting': False,
1639                'background': True,
1640                'color_texture': self.preloaddata['bgtex2'],
1641            },
1642        )
1643        ba.newnode(
1644            'terrain',
1645            attrs={
1646                'model': self.preloaddata['vr_fill_model'],
1647                'lighting': False,
1648                'vr_only': True,
1649                'background': True,
1650                'color_texture': self.preloaddata['bgtex2'],
1651            },
1652        )
1653        self.railing = ba.newnode(
1654            'terrain',
1655            attrs={
1656                'collide_model': self.preloaddata['railing_collide_model'],
1657                'materials': [shared.railing_material],
1658                'bumper': True,
1659            },
1660        )
1661        gnode = ba.getactivity().globalsnode
1662        gnode.tint = (1.2, 1.1, 0.97)
1663        gnode.ambient_color = (1.3, 1.2, 1.03)
1664        gnode.vignette_outer = (0.62, 0.64, 0.69)
1665        gnode.vignette_inner = (0.97, 0.95, 0.93)
1666
1667    def is_point_near_edge(self, point: ba.Vec3, running: bool = False) -> bool:
1668        box_position = self.defs.boxes['edge_box'][0:3]
1669        box_scale = self.defs.boxes['edge_box'][6:9]
1670        xpos = (point.x - box_position[0]) / box_scale[0]
1671        zpos = (point.z - box_position[2]) / box_scale[2]
1672        return xpos < -0.5 or xpos > 0.5 or zpos < -0.5 or zpos > 0.5