# Released under the MIT License. See LICENSE for details.
#
"""Standard maps."""
# pylint: disable=too-many-lines
from __future__ import annotations
from typing import TYPE_CHECKING, override
import bascenev1 as bs
from bascenev1lib.gameutils import SharedObjects
if TYPE_CHECKING:
from typing import Any
[docs]
def register_all_maps() -> None:
"""Registering all maps."""
for maptype in [
HockeyStadium,
FootballStadium,
Bridgit,
BigG,
Roundabout,
MonkeyFace,
ZigZag,
ThePad,
DoomShroom,
LakeFrigid,
TipTop,
CragCastle,
TowerD,
HappyThoughts,
StepRightUp,
Courtyard,
Rampage,
]:
bs.register_map(maptype)
[docs]
class HockeyStadium(bs.Map):
"""Stadium map used for ice hockey games."""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import hockey_stadium as defs
name = 'Hockey Stadium'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return ['melee', 'hockey', 'team_flag', 'keep_away']
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'hockeyStadiumPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'meshes': (
bs.getmesh('hockeyStadiumOuter'),
bs.getmesh('hockeyStadiumInner'),
bs.getmesh('hockeyStadiumStands'),
),
'vr_fill_mesh': bs.getmesh('footballStadiumVRFill'),
'collision_mesh': bs.getcollisionmesh('hockeyStadiumCollide'),
'tex': bs.gettexture('hockeyStadium'),
'stands_tex': bs.gettexture('footballStadium'),
}
mat = bs.Material()
mat.add_actions(actions=('modify_part_collision', 'friction', 0.01))
data['ice_material'] = mat
return data
def __init__(self) -> None:
super().__init__()
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'mesh': self.preloaddata['meshes'][0],
'collision_mesh': self.preloaddata['collision_mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [
shared.footing_material,
self.preloaddata['ice_material'],
],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['vr_fill_mesh'],
'vr_only': True,
'lighting': False,
'background': True,
'color_texture': self.preloaddata['stands_tex'],
},
)
mats = [shared.footing_material, self.preloaddata['ice_material']]
self.floor = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['meshes'][1],
'color_texture': self.preloaddata['tex'],
'opacity': 0.92,
'opacity_in_low_or_medium_quality': 1.0,
'materials': mats,
},
)
self.stands = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['meshes'][2],
'visible_in_reflections': False,
'color_texture': self.preloaddata['stands_tex'],
},
)
gnode = bs.getactivity().globalsnode
gnode.floor_reflection = True
gnode.debris_friction = 0.3
gnode.debris_kill_height = -0.3
gnode.tint = (1.2, 1.3, 1.33)
gnode.ambient_color = (1.15, 1.25, 1.6)
gnode.vignette_outer = (0.66, 0.67, 0.73)
gnode.vignette_inner = (0.93, 0.93, 0.95)
gnode.vr_camera_offset = (0, -0.8, -1.1)
gnode.vr_near_clip = 0.5
self.is_hockey = True
[docs]
class Bridgit(bs.Map):
"""Map with a narrow bridge in the middle."""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import bridgit as defs
name = 'Bridgit'
dataname = 'bridgit'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
# print('getting playtypes', cls._getdata()['play_types'])
return ['melee', 'team_flag', 'keep_away']
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'bridgitPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh_top': bs.getmesh('bridgitLevelTop'),
'mesh_bottom': bs.getmesh('bridgitLevelBottom'),
'mesh_bg': bs.getmesh('natureBackground'),
'bg_vr_fill_mesh': bs.getmesh('natureBackgroundVRFill'),
'collision_mesh': bs.getcollisionmesh('bridgitLevelCollide'),
'tex': bs.gettexture('bridgitLevelColor'),
'mesh_bg_tex': bs.gettexture('natureBackgroundColor'),
'collide_bg': bs.getcollisionmesh('natureBackgroundCollide'),
'railing_collision_mesh': (
bs.getcollisionmesh('bridgitLevelRailingCollide')
),
'bg_material': bs.Material(),
}
data['bg_material'].add_actions(
actions=('modify_part_collision', 'friction', 10.0)
)
return data
def __init__(self) -> None:
super().__init__()
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh_top'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.bottom = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['mesh_bottom'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['mesh_bg'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['mesh_bg_tex'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bg_vr_fill_mesh'],
'lighting': False,
'vr_only': True,
'background': True,
'color_texture': self.preloaddata['mesh_bg_tex'],
},
)
self.railing = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['railing_collision_mesh'],
'materials': [shared.railing_material],
'bumper': True,
},
)
self.bg_collide = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['collide_bg'],
'materials': [
shared.footing_material,
self.preloaddata['bg_material'],
shared.death_material,
],
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (1.1, 1.2, 1.3)
gnode.ambient_color = (1.1, 1.2, 1.3)
gnode.vignette_outer = (0.65, 0.6, 0.55)
gnode.vignette_inner = (0.9, 0.9, 0.93)
[docs]
class BigG(bs.Map):
"""Large G shaped map for racing"""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import big_g as defs
name = 'Big G'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return [
'race',
'melee',
'keep_away',
'team_flag',
'king_of_the_hill',
'conquest',
]
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'bigGPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh_top': bs.getmesh('bigG'),
'mesh_bottom': bs.getmesh('bigGBottom'),
'mesh_bg': bs.getmesh('natureBackground'),
'bg_vr_fill_mesh': bs.getmesh('natureBackgroundVRFill'),
'collision_mesh': bs.getcollisionmesh('bigGCollide'),
'tex': bs.gettexture('bigG'),
'mesh_bg_tex': bs.gettexture('natureBackgroundColor'),
'collide_bg': bs.getcollisionmesh('natureBackgroundCollide'),
'bumper_collision_mesh': bs.getcollisionmesh('bigGBumper'),
'bg_material': bs.Material(),
}
data['bg_material'].add_actions(
actions=('modify_part_collision', 'friction', 10.0)
)
return data
def __init__(self) -> None:
super().__init__()
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'color': (0.7, 0.7, 0.7),
'mesh': self.preloaddata['mesh_top'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.bottom = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['mesh_bottom'],
'color': (0.7, 0.7, 0.7),
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['mesh_bg'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['mesh_bg_tex'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bg_vr_fill_mesh'],
'lighting': False,
'vr_only': True,
'background': True,
'color_texture': self.preloaddata['mesh_bg_tex'],
},
)
self.railing = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['bumper_collision_mesh'],
'materials': [shared.railing_material],
'bumper': True,
},
)
self.bg_collide = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['collide_bg'],
'materials': [
shared.footing_material,
self.preloaddata['bg_material'],
shared.death_material,
],
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (1.1, 1.2, 1.3)
gnode.ambient_color = (1.1, 1.2, 1.3)
gnode.vignette_outer = (0.65, 0.6, 0.55)
gnode.vignette_inner = (0.9, 0.9, 0.93)
[docs]
class Roundabout(bs.Map):
"""CTF map featuring two platforms and a long way around between them"""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import roundabout as defs
name = 'Roundabout'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return ['melee', 'keep_away', 'team_flag']
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'roundaboutPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('roundaboutLevel'),
'mesh_bottom': bs.getmesh('roundaboutLevelBottom'),
'mesh_bg': bs.getmesh('natureBackground'),
'bg_vr_fill_mesh': bs.getmesh('natureBackgroundVRFill'),
'collision_mesh': bs.getcollisionmesh('roundaboutLevelCollide'),
'tex': bs.gettexture('roundaboutLevelColor'),
'mesh_bg_tex': bs.gettexture('natureBackgroundColor'),
'collide_bg': bs.getcollisionmesh('natureBackgroundCollide'),
'railing_collision_mesh': (
bs.getcollisionmesh('roundaboutLevelBumper')
),
'bg_material': bs.Material(),
}
data['bg_material'].add_actions(
actions=('modify_part_collision', 'friction', 10.0)
)
return data
def __init__(self) -> None:
super().__init__(vr_overlay_offset=(0, -1, 1))
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.bottom = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['mesh_bottom'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['mesh_bg'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['mesh_bg_tex'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bg_vr_fill_mesh'],
'lighting': False,
'vr_only': True,
'background': True,
'color_texture': self.preloaddata['mesh_bg_tex'],
},
)
self.bg_collide = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['collide_bg'],
'materials': [
shared.footing_material,
self.preloaddata['bg_material'],
shared.death_material,
],
},
)
self.railing = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['railing_collision_mesh'],
'materials': [shared.railing_material],
'bumper': True,
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (1.0, 1.05, 1.1)
gnode.ambient_color = (1.0, 1.05, 1.1)
gnode.shadow_ortho = True
gnode.vignette_outer = (0.63, 0.65, 0.7)
gnode.vignette_inner = (0.97, 0.95, 0.93)
[docs]
class MonkeyFace(bs.Map):
"""Map sorta shaped like a monkey face; teehee!"""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import monkey_face as defs
name = 'Monkey Face'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return ['melee', 'keep_away', 'team_flag']
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'monkeyFacePreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('monkeyFaceLevel'),
'bottom_mesh': bs.getmesh('monkeyFaceLevelBottom'),
'mesh_bg': bs.getmesh('natureBackground'),
'bg_vr_fill_mesh': bs.getmesh('natureBackgroundVRFill'),
'collision_mesh': bs.getcollisionmesh('monkeyFaceLevelCollide'),
'tex': bs.gettexture('monkeyFaceLevelColor'),
'mesh_bg_tex': bs.gettexture('natureBackgroundColor'),
'collide_bg': bs.getcollisionmesh('natureBackgroundCollide'),
'railing_collision_mesh': (
bs.getcollisionmesh('monkeyFaceLevelBumper')
),
'bg_material': bs.Material(),
}
data['bg_material'].add_actions(
actions=('modify_part_collision', 'friction', 10.0)
)
return data
def __init__(self) -> None:
super().__init__()
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.bottom = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bottom_mesh'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['mesh_bg'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['mesh_bg_tex'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bg_vr_fill_mesh'],
'lighting': False,
'vr_only': True,
'background': True,
'color_texture': self.preloaddata['mesh_bg_tex'],
},
)
self.bg_collide = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['collide_bg'],
'materials': [
shared.footing_material,
self.preloaddata['bg_material'],
shared.death_material,
],
},
)
self.railing = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['railing_collision_mesh'],
'materials': [shared.railing_material],
'bumper': True,
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (1.1, 1.2, 1.2)
gnode.ambient_color = (1.2, 1.3, 1.3)
gnode.vignette_outer = (0.60, 0.62, 0.66)
gnode.vignette_inner = (0.97, 0.95, 0.93)
gnode.vr_camera_offset = (-1.4, 0, 0)
[docs]
class ZigZag(bs.Map):
"""A very long zig-zaggy map"""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import zig_zag as defs
name = 'Zigzag'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return [
'melee',
'keep_away',
'team_flag',
'conquest',
'king_of_the_hill',
]
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'zigzagPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('zigZagLevel'),
'mesh_bottom': bs.getmesh('zigZagLevelBottom'),
'mesh_bg': bs.getmesh('natureBackground'),
'bg_vr_fill_mesh': bs.getmesh('natureBackgroundVRFill'),
'collision_mesh': bs.getcollisionmesh('zigZagLevelCollide'),
'tex': bs.gettexture('zigZagLevelColor'),
'mesh_bg_tex': bs.gettexture('natureBackgroundColor'),
'collide_bg': bs.getcollisionmesh('natureBackgroundCollide'),
'railing_collision_mesh': bs.getcollisionmesh('zigZagLevelBumper'),
'bg_material': bs.Material(),
}
data['bg_material'].add_actions(
actions=('modify_part_collision', 'friction', 10.0)
)
return data
def __init__(self) -> None:
super().__init__()
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['mesh_bg'],
'lighting': False,
'color_texture': self.preloaddata['mesh_bg_tex'],
},
)
self.bottom = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['mesh_bottom'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bg_vr_fill_mesh'],
'lighting': False,
'vr_only': True,
'background': True,
'color_texture': self.preloaddata['mesh_bg_tex'],
},
)
self.bg_collide = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['collide_bg'],
'materials': [
shared.footing_material,
self.preloaddata['bg_material'],
shared.death_material,
],
},
)
self.railing = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['railing_collision_mesh'],
'materials': [shared.railing_material],
'bumper': True,
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (1.0, 1.15, 1.15)
gnode.ambient_color = (1.0, 1.15, 1.15)
gnode.vignette_outer = (0.57, 0.59, 0.63)
gnode.vignette_inner = (0.97, 0.95, 0.93)
gnode.vr_camera_offset = (-1.5, 0, 0)
[docs]
class ThePad(bs.Map):
"""A simple square shaped map with a raised edge."""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import the_pad as defs
name = 'The Pad'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return ['melee', 'keep_away', 'team_flag', 'king_of_the_hill']
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'thePadPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('thePadLevel'),
'bottom_mesh': bs.getmesh('thePadLevelBottom'),
'collision_mesh': bs.getcollisionmesh('thePadLevelCollide'),
'tex': bs.gettexture('thePadLevelColor'),
'bgtex': bs.gettexture('menuBG'),
'bgmesh': bs.getmesh('thePadBG'),
'railing_collision_mesh': bs.getcollisionmesh('thePadLevelBumper'),
'vr_fill_mound_mesh': bs.getmesh('thePadVRFillMound'),
'vr_fill_mound_tex': bs.gettexture('vrFillMound'),
}
# fixme should chop this into vr/non-vr sections for efficiency
return data
def __init__(self) -> None:
super().__init__()
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.bottom = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bottom_mesh'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bgmesh'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['bgtex'],
},
)
self.railing = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['railing_collision_mesh'],
'materials': [shared.railing_material],
'bumper': True,
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['vr_fill_mound_mesh'],
'lighting': False,
'vr_only': True,
'color': (0.56, 0.55, 0.47),
'background': True,
'color_texture': self.preloaddata['vr_fill_mound_tex'],
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (1.1, 1.1, 1.0)
gnode.ambient_color = (1.1, 1.1, 1.0)
gnode.vignette_outer = (0.7, 0.65, 0.75)
gnode.vignette_inner = (0.95, 0.95, 0.93)
[docs]
class DoomShroom(bs.Map):
"""A giant mushroom. Of doom!"""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import doom_shroom as defs
name = 'Doom Shroom'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return ['melee', 'keep_away', 'team_flag']
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'doomShroomPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('doomShroomLevel'),
'collision_mesh': bs.getcollisionmesh('doomShroomLevelCollide'),
'tex': bs.gettexture('doomShroomLevelColor'),
'bgtex': bs.gettexture('doomShroomBGColor'),
'bgmesh': bs.getmesh('doomShroomBG'),
'vr_fill_mesh': bs.getmesh('doomShroomVRFill'),
'stem_mesh': bs.getmesh('doomShroomStem'),
'collide_bg': bs.getcollisionmesh('doomShroomStemCollide'),
}
return data
def __init__(self) -> None:
super().__init__()
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bgmesh'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['bgtex'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['vr_fill_mesh'],
'lighting': False,
'vr_only': True,
'background': True,
'color_texture': self.preloaddata['bgtex'],
},
)
self.stem = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['stem_mesh'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
self.bg_collide = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['collide_bg'],
'materials': [shared.footing_material, shared.death_material],
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (0.82, 1.10, 1.15)
gnode.ambient_color = (0.9, 1.3, 1.1)
gnode.shadow_ortho = False
gnode.vignette_outer = (0.76, 0.76, 0.76)
gnode.vignette_inner = (0.95, 0.95, 0.99)
[docs]
@override
def is_point_near_edge(self, point: bs.Vec3, running: bool = False) -> bool:
xpos = point.x
zpos = point.z
x_adj = xpos * 0.125
z_adj = (zpos + 3.7) * 0.2
if running:
x_adj *= 1.4
z_adj *= 1.4
return x_adj * x_adj + z_adj * z_adj > 1.0
[docs]
class LakeFrigid(bs.Map):
"""An icy lake fit for racing."""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import lake_frigid as defs
name = 'Lake Frigid'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return ['melee', 'keep_away', 'team_flag', 'race']
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'lakeFrigidPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('lakeFrigid'),
'mesh_top': bs.getmesh('lakeFrigidTop'),
'mesh_reflections': bs.getmesh('lakeFrigidReflections'),
'collision_mesh': bs.getcollisionmesh('lakeFrigidCollide'),
'tex': bs.gettexture('lakeFrigid'),
'tex_reflections': bs.gettexture('lakeFrigidReflections'),
'vr_fill_mesh': bs.getmesh('lakeFrigidVRFill'),
}
mat = bs.Material()
mat.add_actions(actions=('modify_part_collision', 'friction', 0.01))
data['ice_material'] = mat
return data
def __init__(self) -> None:
super().__init__()
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [
shared.footing_material,
self.preloaddata['ice_material'],
],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['mesh_top'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['mesh_reflections'],
'lighting': False,
'overlay': True,
'opacity': 0.15,
'color_texture': self.preloaddata['tex_reflections'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['vr_fill_mesh'],
'lighting': False,
'vr_only': True,
'background': True,
'color_texture': self.preloaddata['tex'],
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (1, 1, 1)
gnode.ambient_color = (1, 1, 1)
gnode.shadow_ortho = True
gnode.vignette_outer = (0.86, 0.86, 0.86)
gnode.vignette_inner = (0.95, 0.95, 0.99)
gnode.vr_near_clip = 0.5
self.is_hockey = True
[docs]
class TipTop(bs.Map):
"""A pointy map good for king-of-the-hill-ish games."""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import tip_top as defs
name = 'Tip Top'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return ['melee', 'keep_away', 'team_flag', 'king_of_the_hill']
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'tipTopPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('tipTopLevel'),
'bottom_mesh': bs.getmesh('tipTopLevelBottom'),
'collision_mesh': bs.getcollisionmesh('tipTopLevelCollide'),
'tex': bs.gettexture('tipTopLevelColor'),
'bgtex': bs.gettexture('tipTopBGColor'),
'bgmesh': bs.getmesh('tipTopBG'),
'railing_collision_mesh': bs.getcollisionmesh('tipTopLevelBumper'),
}
return data
def __init__(self) -> None:
super().__init__(vr_overlay_offset=(0, -0.2, 2.5))
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'color': (0.7, 0.7, 0.7),
'materials': [shared.footing_material],
},
)
self.bottom = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bottom_mesh'],
'lighting': False,
'color': (0.7, 0.7, 0.7),
'color_texture': self.preloaddata['tex'],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bgmesh'],
'lighting': False,
'color': (0.4, 0.4, 0.4),
'background': True,
'color_texture': self.preloaddata['bgtex'],
},
)
self.railing = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['railing_collision_mesh'],
'materials': [shared.railing_material],
'bumper': True,
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (0.8, 0.9, 1.3)
gnode.ambient_color = (0.8, 0.9, 1.3)
gnode.vignette_outer = (0.79, 0.79, 0.69)
gnode.vignette_inner = (0.97, 0.97, 0.99)
[docs]
class CragCastle(bs.Map):
"""A lovely castle map."""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import crag_castle as defs
name = 'Crag Castle'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return ['melee', 'keep_away', 'team_flag', 'conquest']
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'cragCastlePreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('cragCastleLevel'),
'bottom_mesh': bs.getmesh('cragCastleLevelBottom'),
'collision_mesh': bs.getcollisionmesh('cragCastleLevelCollide'),
'tex': bs.gettexture('cragCastleLevelColor'),
'bgtex': bs.gettexture('menuBG'),
'bgmesh': bs.getmesh('thePadBG'),
'railing_collision_mesh': (
bs.getcollisionmesh('cragCastleLevelBumper')
),
'vr_fill_mound_mesh': bs.getmesh('cragCastleVRFillMound'),
'vr_fill_mound_tex': bs.gettexture('vrFillMound'),
}
# fixme should chop this into vr/non-vr sections
return data
def __init__(self) -> None:
super().__init__()
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.bottom = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bottom_mesh'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bgmesh'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['bgtex'],
},
)
self.railing = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['railing_collision_mesh'],
'materials': [shared.railing_material],
'bumper': True,
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['vr_fill_mound_mesh'],
'lighting': False,
'vr_only': True,
'color': (0.2, 0.25, 0.2),
'background': True,
'color_texture': self.preloaddata['vr_fill_mound_tex'],
},
)
gnode = bs.getactivity().globalsnode
gnode.shadow_ortho = True
gnode.shadow_offset = (0, 0, -5.0)
gnode.tint = (1.15, 1.05, 0.75)
gnode.ambient_color = (1.15, 1.05, 0.75)
gnode.vignette_outer = (0.6, 0.65, 0.6)
gnode.vignette_inner = (0.95, 0.95, 0.95)
gnode.vr_near_clip = 1.0
[docs]
class TowerD(bs.Map):
"""Map used for runaround mini-game."""
from bascenev1lib.mapdata import tower_d as defs
name = 'Tower D'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return []
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'towerDPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('towerDLevel'),
'mesh_bottom': bs.getmesh('towerDLevelBottom'),
'collision_mesh': bs.getcollisionmesh('towerDLevelCollide'),
'tex': bs.gettexture('towerDLevelColor'),
'bgtex': bs.gettexture('menuBG'),
'bgmesh': bs.getmesh('thePadBG'),
'player_wall_collision_mesh': bs.getcollisionmesh(
'towerDPlayerWall'
),
'player_wall_material': bs.Material(),
}
# fixme should chop this into vr/non-vr sections
data['player_wall_material'].add_actions(
actions=('modify_part_collision', 'friction', 0.0)
)
# anything that needs to hit the wall can apply this material
data['collide_with_wall_material'] = bs.Material()
data['player_wall_material'].add_actions(
conditions=(
'they_dont_have_material',
data['collide_with_wall_material'],
),
actions=('modify_part_collision', 'collide', False),
)
data['vr_fill_mound_mesh'] = bs.getmesh('stepRightUpVRFillMound')
data['vr_fill_mound_tex'] = bs.gettexture('vrFillMound')
return data
def __init__(self) -> None:
super().__init__(vr_overlay_offset=(0, 1, 1))
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.node_bottom = bs.newnode(
'terrain',
delegate=self,
attrs={
'mesh': self.preloaddata['mesh_bottom'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['vr_fill_mound_mesh'],
'lighting': False,
'vr_only': True,
'color': (0.53, 0.57, 0.5),
'background': True,
'color_texture': self.preloaddata['vr_fill_mound_tex'],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bgmesh'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['bgtex'],
},
)
self.player_wall = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata[
'player_wall_collision_mesh'
],
'affect_bg_dynamics': False,
'materials': [self.preloaddata['player_wall_material']],
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (1.15, 1.11, 1.03)
gnode.ambient_color = (1.2, 1.1, 1.0)
gnode.vignette_outer = (0.7, 0.73, 0.7)
gnode.vignette_inner = (0.95, 0.95, 0.95)
[docs]
@override
def is_point_near_edge(self, point: bs.Vec3, running: bool = False) -> bool:
# see if we're within edge_box
boxes = self.defs.boxes
box_position = boxes['edge_box'][0:3]
box_scale = boxes['edge_box'][6:9]
box_position2 = boxes['edge_box2'][0:3]
box_scale2 = boxes['edge_box2'][6:9]
xpos = (point.x - box_position[0]) / box_scale[0]
zpos = (point.z - box_position[2]) / box_scale[2]
xpos2 = (point.x - box_position2[0]) / box_scale2[0]
zpos2 = (point.z - box_position2[2]) / box_scale2[2]
# if we're outside of *both* boxes we're near the edge
return (xpos < -0.5 or xpos > 0.5 or zpos < -0.5 or zpos > 0.5) and (
xpos2 < -0.5 or xpos2 > 0.5 or zpos2 < -0.5 or zpos2 > 0.5
)
[docs]
class HappyThoughts(bs.Map):
"""Flying map."""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import happy_thoughts as defs
name = 'Happy Thoughts'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return [
'melee',
'keep_away',
'team_flag',
'conquest',
'king_of_the_hill',
]
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'alwaysLandPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('alwaysLandLevel'),
'bottom_mesh': bs.getmesh('alwaysLandLevelBottom'),
'bgmesh': bs.getmesh('alwaysLandBG'),
'collision_mesh': bs.getcollisionmesh('alwaysLandLevelCollide'),
'tex': bs.gettexture('alwaysLandLevelColor'),
'bgtex': bs.gettexture('alwaysLandBGColor'),
'vr_fill_mound_mesh': bs.getmesh('alwaysLandVRFillMound'),
'vr_fill_mound_tex': bs.gettexture('vrFillMound'),
}
return data
[docs]
@override
@classmethod
def get_music_type(cls) -> bs.MusicType:
return bs.MusicType.FLYING
def __init__(self) -> None:
super().__init__(vr_overlay_offset=(0, -3.7, 2.5))
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.bottom = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bottom_mesh'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bgmesh'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['bgtex'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['vr_fill_mound_mesh'],
'lighting': False,
'vr_only': True,
'color': (0.2, 0.25, 0.2),
'background': True,
'color_texture': self.preloaddata['vr_fill_mound_tex'],
},
)
gnode = bs.getactivity().globalsnode
gnode.happy_thoughts_mode = True
gnode.shadow_offset = (0.0, 8.0, 5.0)
gnode.tint = (1.3, 1.23, 1.0)
gnode.ambient_color = (1.3, 1.23, 1.0)
gnode.vignette_outer = (0.64, 0.59, 0.69)
gnode.vignette_inner = (0.95, 0.95, 0.93)
gnode.vr_near_clip = 1.0
self.is_flying = True
# throw out some tips on flying
txt = bs.newnode(
'text',
attrs={
'text': bs.Lstr(resource='pressJumpToFlyText'),
'scale': 1.2,
'maxwidth': 800,
'position': (0, 200),
'shadow': 0.5,
'flatness': 0.5,
'h_align': 'center',
'v_attach': 'bottom',
},
)
cmb = bs.newnode(
'combine',
owner=txt,
attrs={'size': 4, 'input0': 0.3, 'input1': 0.9, 'input2': 0.0},
)
bs.animate(cmb, 'input3', {3.0: 0, 4.0: 1, 9.0: 1, 10.0: 0})
cmb.connectattr('output', txt, 'color')
bs.timer(10.0, txt.delete)
[docs]
class StepRightUp(bs.Map):
"""Wide stepped map good for CTF or Assault."""
# noinspection PyUnresolvedReferences
from bascenev1lib.mapdata import step_right_up as defs
name = 'Step Right Up'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return ['melee', 'keep_away', 'team_flag', 'conquest']
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'stepRightUpPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('stepRightUpLevel'),
'mesh_bottom': bs.getmesh('stepRightUpLevelBottom'),
'collision_mesh': bs.getcollisionmesh('stepRightUpLevelCollide'),
'tex': bs.gettexture('stepRightUpLevelColor'),
'bgtex': bs.gettexture('menuBG'),
'bgmesh': bs.getmesh('thePadBG'),
'vr_fill_mound_mesh': bs.getmesh('stepRightUpVRFillMound'),
'vr_fill_mound_tex': bs.gettexture('vrFillMound'),
}
# fixme should chop this into vr/non-vr chunks
return data
def __init__(self) -> None:
super().__init__(vr_overlay_offset=(0, -1, 2))
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.node_bottom = bs.newnode(
'terrain',
delegate=self,
attrs={
'mesh': self.preloaddata['mesh_bottom'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['vr_fill_mound_mesh'],
'lighting': False,
'vr_only': True,
'color': (0.53, 0.57, 0.5),
'background': True,
'color_texture': self.preloaddata['vr_fill_mound_tex'],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bgmesh'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['bgtex'],
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (1.2, 1.1, 1.0)
gnode.ambient_color = (1.2, 1.1, 1.0)
gnode.vignette_outer = (0.7, 0.65, 0.75)
gnode.vignette_inner = (0.95, 0.95, 0.93)
[docs]
class Courtyard(bs.Map):
"""A courtyard-ish looking map for co-op levels."""
from bascenev1lib.mapdata import courtyard as defs
name = 'Courtyard'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return ['melee', 'keep_away', 'team_flag']
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'courtyardPreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('courtyardLevel'),
'mesh_bottom': bs.getmesh('courtyardLevelBottom'),
'collision_mesh': bs.getcollisionmesh('courtyardLevelCollide'),
'tex': bs.gettexture('courtyardLevelColor'),
'bgtex': bs.gettexture('menuBG'),
'bgmesh': bs.getmesh('thePadBG'),
'player_wall_collision_mesh': (
bs.getcollisionmesh('courtyardPlayerWall')
),
'player_wall_material': bs.Material(),
}
# FIXME: Chop this into vr and non-vr chunks.
data['player_wall_material'].add_actions(
actions=('modify_part_collision', 'friction', 0.0)
)
# anything that needs to hit the wall should apply this.
data['collide_with_wall_material'] = bs.Material()
data['player_wall_material'].add_actions(
conditions=(
'they_dont_have_material',
data['collide_with_wall_material'],
),
actions=('modify_part_collision', 'collide', False),
)
data['vr_fill_mound_mesh'] = bs.getmesh('stepRightUpVRFillMound')
data['vr_fill_mound_tex'] = bs.gettexture('vrFillMound')
return data
def __init__(self) -> None:
super().__init__()
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bgmesh'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['bgtex'],
},
)
self.bottom = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['mesh_bottom'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['vr_fill_mound_mesh'],
'lighting': False,
'vr_only': True,
'color': (0.53, 0.57, 0.5),
'background': True,
'color_texture': self.preloaddata['vr_fill_mound_tex'],
},
)
# in co-op mode games, put up a wall to prevent players
# from getting in the turrets (that would foil our brilliant AI)
if isinstance(bs.getsession(), bs.CoopSession):
cmesh = self.preloaddata['player_wall_collision_mesh']
self.player_wall = bs.newnode(
'terrain',
attrs={
'collision_mesh': cmesh,
'affect_bg_dynamics': False,
'materials': [self.preloaddata['player_wall_material']],
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (1.2, 1.17, 1.1)
gnode.ambient_color = (1.2, 1.17, 1.1)
gnode.vignette_outer = (0.6, 0.6, 0.64)
gnode.vignette_inner = (0.95, 0.95, 0.93)
[docs]
@override
def is_point_near_edge(self, point: bs.Vec3, running: bool = False) -> bool:
# count anything off our ground level as safe (for our platforms)
# see if we're within edge_box
box_position = self.defs.boxes['edge_box'][0:3]
box_scale = self.defs.boxes['edge_box'][6:9]
xpos = (point.x - box_position[0]) / box_scale[0]
zpos = (point.z - box_position[2]) / box_scale[2]
return xpos < -0.5 or xpos > 0.5 or zpos < -0.5 or zpos > 0.5
[docs]
class Rampage(bs.Map):
"""Wee little map with ramps on the sides."""
from bascenev1lib.mapdata import rampage as defs
name = 'Rampage'
[docs]
@override
@classmethod
def get_play_types(cls) -> list[str]:
"""Return valid play types for this map."""
return ['melee', 'keep_away', 'team_flag']
[docs]
@override
@classmethod
def get_preview_texture_name(cls) -> str:
return 'rampagePreview'
[docs]
@override
@classmethod
def on_preload(cls) -> Any:
data: dict[str, Any] = {
'mesh': bs.getmesh('rampageLevel'),
'bottom_mesh': bs.getmesh('rampageLevelBottom'),
'collision_mesh': bs.getcollisionmesh('rampageLevelCollide'),
'tex': bs.gettexture('rampageLevelColor'),
'bgtex': bs.gettexture('rampageBGColor'),
'bgtex2': bs.gettexture('rampageBGColor2'),
'bgmesh': bs.getmesh('rampageBG'),
'bgmesh2': bs.getmesh('rampageBG2'),
'vr_fill_mesh': bs.getmesh('rampageVRFill'),
'railing_collision_mesh': bs.getcollisionmesh('rampageBumper'),
}
return data
def __init__(self) -> None:
super().__init__(vr_overlay_offset=(0, 0, 2))
shared = SharedObjects.get()
self.node = bs.newnode(
'terrain',
delegate=self,
attrs={
'collision_mesh': self.preloaddata['collision_mesh'],
'mesh': self.preloaddata['mesh'],
'color_texture': self.preloaddata['tex'],
'materials': [shared.footing_material],
},
)
self.background = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bgmesh'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['bgtex'],
},
)
self.bottom = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bottom_mesh'],
'lighting': False,
'color_texture': self.preloaddata['tex'],
},
)
self.bg2 = bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['bgmesh2'],
'lighting': False,
'background': True,
'color_texture': self.preloaddata['bgtex2'],
},
)
bs.newnode(
'terrain',
attrs={
'mesh': self.preloaddata['vr_fill_mesh'],
'lighting': False,
'vr_only': True,
'background': True,
'color_texture': self.preloaddata['bgtex2'],
},
)
self.railing = bs.newnode(
'terrain',
attrs={
'collision_mesh': self.preloaddata['railing_collision_mesh'],
'materials': [shared.railing_material],
'bumper': True,
},
)
gnode = bs.getactivity().globalsnode
gnode.tint = (1.2, 1.1, 0.97)
gnode.ambient_color = (1.3, 1.2, 1.03)
gnode.vignette_outer = (0.62, 0.64, 0.69)
gnode.vignette_inner = (0.97, 0.95, 0.93)
[docs]
@override
def is_point_near_edge(self, point: bs.Vec3, running: bool = False) -> bool:
box_position = self.defs.boxes['edge_box'][0:3]
box_scale = self.defs.boxes['edge_box'][6:9]
xpos = (point.x - box_position[0]) / box_scale[0]
zpos = (point.z - box_position[2]) / box_scale[2]
return xpos < -0.5 or xpos > 0.5 or zpos < -0.5 or zpos > 0.5
# Docs-generation hack; import some stuff that we likely only forward-declared
# in our actual source code so that docs tools can find it.
from typing import (Coroutine, Any, Literal, Callable,
Generator, Awaitable, Sequence, Self)
import asyncio
from concurrent.futures import Future
from pathlib import Path
from enum import Enum