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