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