533 lines
13 KiB
TypeScript
533 lines
13 KiB
TypeScript
import { Color } from "../engine/render/Color"
|
|
import type { Material } from "../engine/render/Material"
|
|
import type { CloudLayer, SkyConfig } from "../engine/render/Sky"
|
|
import { ChunkBuilder } from "../engine/render/ChunkBuilder"
|
|
import { Actor, type ActorDefinition } from "../engine/scene/Actor"
|
|
import { Mesh } from "../engine/scene/Mesh"
|
|
import { MeshBuilder } from "../engine/scene/MeshBuilder"
|
|
import {
|
|
Prefab,
|
|
type PlacedPrefab,
|
|
type Prefab as PrefabDefinition,
|
|
} from "../engine/scene/Prefab"
|
|
import type { BoxCollider, Collider } from "../engine/world/Collider"
|
|
import { Level, type Level as RuntimeLevel } from "../engine/world/Level"
|
|
import {
|
|
Terrain,
|
|
type RollingTerrainConfig,
|
|
type Terrain as Ground,
|
|
} from "../engine/world/Terrain"
|
|
import { Boulder } from "./actors/Boulder"
|
|
import { Bush } from "./actors/Bush"
|
|
import { Flower, type FlowerStyle } from "./actors/Flower"
|
|
import type { Mob, MobState } from "./actors/Mob"
|
|
import type { Tree } from "./actors/Tree"
|
|
import { Bee } from "./actors/mobs/Bee"
|
|
import { Frog } from "./actors/mobs/Frog"
|
|
import { Robin } from "./actors/mobs/Robin"
|
|
import { Birch } from "./actors/trees/Birch"
|
|
import { Oak } from "./actors/trees/Oak"
|
|
import { Spruce } from "./actors/trees/Spruce"
|
|
import type { Textures } from "./textures"
|
|
|
|
type Materials = {
|
|
floor: Material
|
|
grass: Material
|
|
bark: Material
|
|
birch: Material
|
|
leaf: Material
|
|
needle: Material
|
|
rock: Material
|
|
flower: Material
|
|
wall: Material
|
|
crate: Material
|
|
npc: Material
|
|
frog: Material
|
|
bee: Material
|
|
robin: Material
|
|
}
|
|
|
|
type WeightedTree = {
|
|
definition: PrefabDefinition<Tree>
|
|
weight: number
|
|
}
|
|
|
|
type MobSpawn = {
|
|
definition: ActorDefinition<MobState, Ground>
|
|
count: number
|
|
minScale: number
|
|
maxScale: number
|
|
grounded: boolean
|
|
phase: (random: () => number) => number
|
|
}
|
|
|
|
const ARENA = 12
|
|
const WALL_HEIGHT = 4
|
|
const WALL_THICKNESS = 1.5
|
|
const CRATE = { x: -2, z: -2, half: 1, height: 1 }
|
|
const FLOOR_LIFT = 0.02
|
|
|
|
const TERRAIN_CONFIG: RollingTerrainConfig = {
|
|
inner: ARENA,
|
|
outer: ARENA * 10,
|
|
blend: 12,
|
|
amplitude: 5,
|
|
frequency: 0.14,
|
|
peakHeight: 0,
|
|
peakFrequency: 0.05,
|
|
peakStart: 0.45,
|
|
}
|
|
const TERRAIN = Terrain.rolling(TERRAIN_CONFIG)
|
|
|
|
const TREE_COUNT = 50
|
|
const TREE_SEED = 0x5EED
|
|
const TREE_REACH = 1
|
|
const BOULDER_COUNT = 50
|
|
const BOULDER_SEED = 0xB0142
|
|
const BOULDER_REACH = 1
|
|
const BUSH_COUNT = 50
|
|
const BUSH_SEED = 0xB554
|
|
const BUSH_REACH = 1
|
|
const FLOWER_COUNT = 50
|
|
const FLOWER_SEED = 0xF10E
|
|
const FLOWER_REACH = 0.3
|
|
const FLOWER_STYLES: FlowerStyle[] = [Flower.white, Flower.red, Flower.yellow]
|
|
const FROG_COUNT = 20
|
|
const BEE_COUNT = 20
|
|
const ROBIN_COUNT = 20
|
|
const MOB_SEED = 0x30B
|
|
const MOB_REACH = 1
|
|
const CHUNK_GRID = 12
|
|
const TERRAIN_SUBDIV = 5
|
|
const GROUND_UV = 0.25
|
|
|
|
export const basicCumulus: CloudLayer = {
|
|
kind: "basic",
|
|
color: Color.rgb(248, 250, 255),
|
|
coverage: 0.5,
|
|
scale: 0.9,
|
|
speed: 0.5,
|
|
edge: 0.005,
|
|
}
|
|
|
|
export const fancyCumulus: CloudLayer = {
|
|
kind: "fancy",
|
|
color: Color.rgb(250, 251, 255),
|
|
coverage: 0.5,
|
|
scale: 0.6,
|
|
speed: 0.5,
|
|
edge: 0.02,
|
|
warp: 0.4,
|
|
relief: 7,
|
|
}
|
|
|
|
/** Concrete playground data assembled through engine-owned level mechanisms. */
|
|
export function buildLevel(textures: Textures): RuntimeLevel<Ground> {
|
|
const materials = createMaterials(textures)
|
|
const floor = Mesh.create()
|
|
MeshBuilder.quad(
|
|
floor,
|
|
[-ARENA, FLOOR_LIFT, -ARENA],
|
|
[ARENA, FLOOR_LIFT, -ARENA],
|
|
[ARENA, FLOOR_LIFT, ARENA],
|
|
[-ARENA, FLOOR_LIFT, ARENA],
|
|
12,
|
|
12,
|
|
)
|
|
|
|
const walls = Mesh.create()
|
|
const thickness = WALL_THICKNESS
|
|
MeshBuilder.slab(
|
|
walls,
|
|
-ARENA,
|
|
ARENA,
|
|
ARENA - thickness,
|
|
ARENA,
|
|
0,
|
|
WALL_HEIGHT,
|
|
0.5,
|
|
)
|
|
MeshBuilder.slab(
|
|
walls,
|
|
ARENA - thickness,
|
|
ARENA,
|
|
-ARENA,
|
|
ARENA - thickness,
|
|
0,
|
|
WALL_HEIGHT,
|
|
0.5,
|
|
)
|
|
MeshBuilder.slab(
|
|
walls,
|
|
-ARENA,
|
|
-ARENA + thickness,
|
|
-ARENA,
|
|
ARENA - thickness,
|
|
0,
|
|
WALL_HEIGHT,
|
|
0.5,
|
|
)
|
|
|
|
const crate = Mesh.create()
|
|
MeshBuilder.box(crate, CRATE.x, CRATE.z, CRATE.half, 0, CRATE.height)
|
|
|
|
const npcPosition = { x: 2, y: 0, z: -1 }
|
|
const staticColliders: Collider[] = [
|
|
wall(-ARENA, ARENA, ARENA - thickness, ARENA),
|
|
wall(ARENA - thickness, ARENA, -ARENA, ARENA - thickness),
|
|
wall(-ARENA, -ARENA + thickness, -ARENA, ARENA - thickness),
|
|
{
|
|
shape: "box",
|
|
minX: CRATE.x - CRATE.half,
|
|
maxX: CRATE.x + CRATE.half,
|
|
minZ: CRATE.z - CRATE.half,
|
|
maxZ: CRATE.z + CRATE.half,
|
|
top: CRATE.height,
|
|
standable: true,
|
|
},
|
|
{
|
|
shape: "circle",
|
|
x: npcPosition.x,
|
|
z: npcPosition.z,
|
|
radius: 0.5,
|
|
top: Infinity,
|
|
standable: false,
|
|
},
|
|
]
|
|
|
|
const treeDefinitions: WeightedTree[] = [
|
|
{ definition: Oak.create(materials.bark, materials.leaf), weight: 0.4 },
|
|
{
|
|
definition: Spruce.create(materials.bark, materials.needle),
|
|
weight: 0.32,
|
|
},
|
|
{ definition: Birch.create(materials.birch, materials.leaf), weight: 0.28 },
|
|
]
|
|
const props = [
|
|
...placeTrees(treeDefinitions),
|
|
...placeBoulders(Boulder.create(materials.rock)),
|
|
...placeBushes(Bush.create(materials.leaf)),
|
|
...placeFlowers(Flower.create(materials.flower)),
|
|
]
|
|
for (const prop of props) {
|
|
if (prop.collider !== null) {
|
|
staticColliders.push(prop.collider)
|
|
}
|
|
}
|
|
|
|
const chunks = ChunkBuilder.build(
|
|
{
|
|
minX: TERRAIN.minX,
|
|
minZ: TERRAIN.minZ,
|
|
maxX: TERRAIN.maxX,
|
|
maxZ: TERRAIN.maxZ,
|
|
columns: CHUNK_GRID,
|
|
rows: CHUNK_GRID,
|
|
bakeCell(near, far, cell) {
|
|
const ground = near.mesh(materials.grass)
|
|
far.use(materials.grass, ground)
|
|
Terrain.patch(
|
|
TERRAIN,
|
|
ground,
|
|
cell.x0,
|
|
cell.z0,
|
|
cell.x1,
|
|
cell.z1,
|
|
TERRAIN_SUBDIV,
|
|
TERRAIN_SUBDIV,
|
|
GROUND_UV,
|
|
(x, z) => Math.max(Math.abs(x), Math.abs(z)) >= ARENA,
|
|
)
|
|
},
|
|
},
|
|
props,
|
|
)
|
|
|
|
const frog = Frog.create(materials.frog)
|
|
const bee = Bee.create(materials.bee)
|
|
const robin = Robin.create(materials.robin)
|
|
const actors = placeMobs([
|
|
{
|
|
definition: frog,
|
|
count: FROG_COUNT,
|
|
minScale: 0.5,
|
|
maxScale: 0.85,
|
|
grounded: true,
|
|
phase: () => 0,
|
|
},
|
|
{
|
|
definition: bee,
|
|
count: BEE_COUNT,
|
|
minScale: 0.5,
|
|
maxScale: 0.8,
|
|
grounded: false,
|
|
phase: (random) => random() * 10,
|
|
},
|
|
{
|
|
definition: robin,
|
|
count: ROBIN_COUNT,
|
|
minScale: 0.4,
|
|
maxScale: 0.65,
|
|
grounded: true,
|
|
phase: () => 0,
|
|
},
|
|
])
|
|
|
|
const sky: SkyConfig = {
|
|
zenith: Color.rgb(58, 108, 196),
|
|
horizon: Color.rgb(178, 198, 226),
|
|
sun: Color.rgb(255, 246, 214),
|
|
sunDir: { x: 0.3, y: 0.5, z: -0.8 },
|
|
sunSize: 0.04,
|
|
clouds: fancyCumulus,
|
|
skybox: { texture: textures.skybox },
|
|
}
|
|
|
|
return Level.create({
|
|
terrain: TERRAIN,
|
|
actorWorld: TERRAIN,
|
|
actors,
|
|
staticColliders,
|
|
staticGroups: [
|
|
{ mesh: floor, material: materials.floor },
|
|
{ mesh: walls, material: materials.wall },
|
|
{ mesh: crate, material: materials.crate },
|
|
],
|
|
chunks,
|
|
billboards: [
|
|
{
|
|
position: npcPosition,
|
|
size: { x: 1.1, y: 1.5 },
|
|
material: materials.npc,
|
|
},
|
|
],
|
|
sky,
|
|
})
|
|
}
|
|
|
|
function createMaterials(textures: Textures): Materials {
|
|
return {
|
|
floor: { texture: textures.floor, cull: false },
|
|
grass: { texture: textures.grass, cull: true },
|
|
bark: { texture: textures.bark, cull: true },
|
|
birch: { texture: textures.birch, cull: true },
|
|
leaf: { texture: textures.leaf, cull: true },
|
|
needle: { texture: textures.needle, cull: true },
|
|
rock: { texture: textures.rock, cull: true },
|
|
flower: { texture: textures.flower, cull: false },
|
|
wall: { texture: textures.wall, cull: false },
|
|
crate: { texture: textures.crate, cull: false },
|
|
npc: { texture: textures.npc, cull: false },
|
|
frog: { texture: textures.frog, cull: false },
|
|
bee: { texture: textures.bee, cull: false },
|
|
robin: { texture: textures.robin, cull: false },
|
|
}
|
|
}
|
|
|
|
function placeTrees(definitions: WeightedTree[]): PlacedPrefab[] {
|
|
const random = mulberry(TREE_SEED)
|
|
const maxDistance = TERRAIN_CONFIG.outer * TREE_REACH
|
|
const trees: PlacedPrefab[] = []
|
|
for (
|
|
let guard = 0;
|
|
trees.length < TREE_COUNT && guard < TREE_COUNT * 20;
|
|
guard++
|
|
) {
|
|
const point = scatterPoint(random, maxDistance, 5, 3)
|
|
if (point === null) {
|
|
continue
|
|
}
|
|
const definition = weightedTree(definitions, random())
|
|
const tree: Tree = {
|
|
position: {
|
|
x: point.x,
|
|
y: TERRAIN.heightAt(point.x, point.z),
|
|
z: point.z,
|
|
},
|
|
growth: 0.08 + random() * 0.92,
|
|
seed: (random() * 0xFFFFFFFF) | 0,
|
|
}
|
|
trees.push(Prefab.place(definition, tree))
|
|
}
|
|
return trees
|
|
}
|
|
|
|
function placeBoulders(definition: PrefabDefinition<Boulder>): PlacedPrefab[] {
|
|
const random = mulberry(BOULDER_SEED)
|
|
const maxDistance = TERRAIN_CONFIG.outer * BOULDER_REACH
|
|
const boulders: PlacedPrefab[] = []
|
|
for (
|
|
let guard = 0;
|
|
boulders.length < BOULDER_COUNT && guard < BOULDER_COUNT * 20;
|
|
guard++
|
|
) {
|
|
const point = scatterPoint(random, maxDistance, 4, 2)
|
|
if (point === null) {
|
|
continue
|
|
}
|
|
boulders.push(
|
|
Prefab.place(definition, {
|
|
position: {
|
|
x: point.x,
|
|
y: TERRAIN.heightAt(point.x, point.z),
|
|
z: point.z,
|
|
},
|
|
radius: 0.35 + random() * random() * 2.2,
|
|
seed: (random() * 0xFFFFFFFF) | 0,
|
|
}),
|
|
)
|
|
}
|
|
return boulders
|
|
}
|
|
|
|
function placeBushes(definition: PrefabDefinition<Bush>): PlacedPrefab[] {
|
|
const random = mulberry(BUSH_SEED)
|
|
const maxDistance = TERRAIN_CONFIG.outer * BUSH_REACH
|
|
const bushes: PlacedPrefab[] = []
|
|
for (
|
|
let guard = 0;
|
|
bushes.length < BUSH_COUNT && guard < BUSH_COUNT * 20;
|
|
guard++
|
|
) {
|
|
const point = scatterPoint(random, maxDistance, 3, 2)
|
|
if (point === null) {
|
|
continue
|
|
}
|
|
bushes.push(
|
|
Prefab.place(definition, {
|
|
position: {
|
|
x: point.x,
|
|
y: TERRAIN.heightAt(point.x, point.z),
|
|
z: point.z,
|
|
},
|
|
size: 0.8 + random(),
|
|
seed: (random() * 0xFFFFFFFF) | 0,
|
|
}),
|
|
)
|
|
}
|
|
return bushes
|
|
}
|
|
|
|
function placeFlowers(definition: PrefabDefinition<Flower>): PlacedPrefab[] {
|
|
const random = mulberry(FLOWER_SEED)
|
|
const maxDistance = TERRAIN_CONFIG.outer * FLOWER_REACH
|
|
const flowers: PlacedPrefab[] = []
|
|
for (
|
|
let guard = 0;
|
|
flowers.length < FLOWER_COUNT && guard < FLOWER_COUNT * 20;
|
|
guard++
|
|
) {
|
|
const point = scatterPoint(random, maxDistance, 2, 1)
|
|
if (point === null) {
|
|
continue
|
|
}
|
|
flowers.push(
|
|
Prefab.place(definition, {
|
|
position: {
|
|
x: point.x,
|
|
y: TERRAIN.heightAt(point.x, point.z),
|
|
z: point.z,
|
|
},
|
|
style: FLOWER_STYLES[(random() * FLOWER_STYLES.length) | 0],
|
|
size: 0.28 + random() * 0.22,
|
|
seed: (random() * 0xFFFFFFFF) | 0,
|
|
}),
|
|
)
|
|
}
|
|
return flowers
|
|
}
|
|
|
|
function placeMobs(spawns: MobSpawn[]): Mob[] {
|
|
const random = mulberry(MOB_SEED)
|
|
const maxDistance = TERRAIN_CONFIG.outer * MOB_REACH
|
|
const mobs: Mob[] = []
|
|
for (const spawn of spawns) {
|
|
let placed = 0
|
|
for (
|
|
let guard = 0;
|
|
placed < spawn.count && guard < spawn.count * 20;
|
|
guard++
|
|
) {
|
|
const point = scatterPoint(random, maxDistance, 3, 2)
|
|
if (point === null) {
|
|
continue
|
|
}
|
|
const y = TERRAIN.heightAt(point.x, point.z)
|
|
const scale = spawn.minScale + random() * (spawn.maxScale - spawn.minScale)
|
|
const heading = random() * Math.PI * 2
|
|
const state: MobState = {
|
|
home: { x: point.x, y, z: point.z },
|
|
position: { x: point.x, y, z: point.z },
|
|
heading,
|
|
scale,
|
|
seed: (random() * 0xFFFFFFFF) | 0,
|
|
vx: 0,
|
|
vz: 0,
|
|
vy: 0,
|
|
timer: random() * 1.5,
|
|
phase: spawn.phase(random),
|
|
grounded: spawn.grounded,
|
|
}
|
|
mobs.push(Actor.create(spawn.definition, state))
|
|
placed++
|
|
}
|
|
}
|
|
return mobs
|
|
}
|
|
|
|
function scatterPoint(
|
|
random: () => number,
|
|
maxDistance: number,
|
|
clearance: number,
|
|
flatMargin: number,
|
|
): { x: number; z: number } | null {
|
|
const angle = random() * Math.PI * 2
|
|
const distance =
|
|
ARENA + clearance + random() * (maxDistance - ARENA - clearance)
|
|
const x = Math.cos(angle) * distance
|
|
const z = Math.sin(angle) * distance
|
|
return Math.max(Math.abs(x), Math.abs(z)) < TERRAIN_CONFIG.inner + flatMargin
|
|
? null
|
|
: { x, z }
|
|
}
|
|
|
|
function weightedTree(
|
|
definitions: WeightedTree[],
|
|
roll: number,
|
|
): PrefabDefinition<Tree> {
|
|
let cumulative = 0
|
|
for (const entry of definitions) {
|
|
cumulative += entry.weight
|
|
if (roll < cumulative) {
|
|
return entry.definition
|
|
}
|
|
}
|
|
return definitions[definitions.length - 1].definition
|
|
}
|
|
|
|
function wall(
|
|
minX: number,
|
|
maxX: number,
|
|
minZ: number,
|
|
maxZ: number,
|
|
): BoxCollider {
|
|
return {
|
|
shape: "box",
|
|
minX,
|
|
maxX,
|
|
minZ,
|
|
maxZ,
|
|
top: WALL_HEIGHT,
|
|
standable: true,
|
|
}
|
|
}
|
|
|
|
function mulberry(seed: number): () => number {
|
|
let state = seed >>> 0
|
|
return () => {
|
|
state = (state + 0x6D2B79F5) | 0
|
|
let value = Math.imul(state ^ (state >>> 15), 1 | state)
|
|
value ^= value + Math.imul(value ^ (value >>> 7), 61 | value)
|
|
return ((value ^ (value >>> 14)) >>> 0) / 4294967296
|
|
}
|
|
}
|