mirror of
https://github.com/misode/misode.github.io.git
synced 2026-04-23 15:17:09 +00:00
425 lines
14 KiB
TypeScript
425 lines
14 KiB
TypeScript
import type { BlockPos, ChunkPos, PerlinNoise, Random } from 'deepslate/worldgen'
|
|
import type { VersionId } from '../../services/index.js'
|
|
import { checkVersion } from '../../services/index.js'
|
|
import type { Color } from '../../Utils.js'
|
|
import { clamp, isObject, stringToColor } from '../../Utils.js'
|
|
|
|
export type Placement = [BlockPos, number]
|
|
|
|
export type PlacementContext = {
|
|
placements: Placement[],
|
|
features: string[],
|
|
random: Random,
|
|
biomeInfoNoise: PerlinNoise,
|
|
seaLevel: number,
|
|
version: VersionId,
|
|
nextFloat(): number,
|
|
nextInt(max: number): number,
|
|
nextGaussian(): number,
|
|
}
|
|
|
|
export type PlacedFeature = {
|
|
pos: BlockPos,
|
|
feature: string,
|
|
color: Color,
|
|
}
|
|
|
|
const terrain = [50, 50, 51, 51, 52, 52, 53, 54, 56, 57, 57, 58, 58, 59, 60, 60, 60, 59, 59, 59, 60, 61, 61, 62, 63, 63, 64, 64, 64, 65, 65, 66, 66, 65, 65, 66, 66, 67, 67, 67, 68, 69, 71, 73, 74, 76, 79, 80, 81, 81, 82, 83, 83, 82, 82, 81, 81, 80, 80, 80, 81, 81, 82, 82]
|
|
|
|
export const featureColors: Color[] = [
|
|
[255, 77, 54], // red
|
|
[59, 118, 255], // blue
|
|
[91, 207, 25], // green
|
|
[217, 32, 245], // magenta
|
|
[255, 209, 41], // yellow
|
|
[52, 204, 209], // cyan
|
|
]
|
|
|
|
export function decorateChunk(pos: ChunkPos, state: any, ctx: PlacementContext): PlacedFeature[] {
|
|
if (checkVersion(ctx.version, undefined, '1.17')) {
|
|
getPlacements([pos[0] * 16, 0, pos[1] * 16], state, ctx)
|
|
} else {
|
|
modifyPlacement([pos[0] * 16, 0, pos[1] * 16], state.placement, ctx)
|
|
}
|
|
|
|
return ctx.placements.map(([pos, i]) => {
|
|
const feature = ctx.features[i]
|
|
let color = i < featureColors.length ? featureColors[i] : stringToColor(feature)
|
|
color = [clamp(color[0], 50, 205), clamp(color[1], 50, 205), clamp(color[2], 50, 205)]
|
|
if ((Math.floor(pos[0] / 16) + Math.floor(pos[2] / 16)) % 2 === 0) {
|
|
color = [0.85 * color[0], 0.85 * color[1], 0.85 * color[2]]
|
|
}
|
|
return { pos, feature, color }
|
|
})
|
|
}
|
|
|
|
function normalize(id: string) {
|
|
return id.startsWith('minecraft:') ? id.slice(10) : id
|
|
}
|
|
|
|
function decorateY(pos: BlockPos, y: number): BlockPos[] {
|
|
return [[ pos[0], y, pos[2] ]]
|
|
}
|
|
|
|
export function sampleInt(value: any, ctx: PlacementContext): number {
|
|
if (value === undefined) {
|
|
return 0
|
|
} else if (typeof value === 'number') {
|
|
return value
|
|
} else if (value.base) {
|
|
return value.base ?? 1 + ctx.nextInt(1 + (value.spread ?? 0))
|
|
} else {
|
|
switch (normalize(value.type)) {
|
|
case 'constant': return value.value
|
|
case 'uniform': return value.value.min_inclusive + ctx.nextInt(value.value.max_inclusive - value.value.min_inclusive + 1)
|
|
case 'biased_to_bottom': return value.value.min_inclusive + ctx.nextInt(ctx.nextInt(value.value.max_inclusive - value.value.min_inclusive + 1) + 1)
|
|
case 'clamped': return clamp(sampleInt(value.value.source, ctx), value.value.min_inclusive, value.value.max_inclusive)
|
|
case 'clamped_normal':
|
|
const normal = value.value.mean + ctx.nextGaussian() * value.value.deviation
|
|
return Math.floor(clamp(value.value.min_inclusive, value.value.max_inclusive, normal))
|
|
case 'weighted_list':
|
|
const totalWeight = (value.distribution as any[]).reduce<number>((sum, e) => sum + e.weight, 0)
|
|
let i = ctx.nextInt(totalWeight)
|
|
for (const e of value.distribution) {
|
|
i -= e.weight
|
|
if (i < 0) return sampleInt(e.data, ctx)
|
|
}
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
}
|
|
|
|
function resolveAnchor(anchor: any, _ctx: PlacementContext): number {
|
|
if (!isObject(anchor)) return 0
|
|
if (anchor.absolute !== undefined) return anchor.absolute
|
|
if (anchor.above_bottom !== undefined) return anchor.above_bottom
|
|
if (anchor.below_top !== undefined) return 256 - anchor.below_top
|
|
return 0
|
|
}
|
|
|
|
function sampleHeight(height: any, ctx: PlacementContext): number {
|
|
if (!isObject(height)) throw new Error('Invalid height provider')
|
|
if (typeof height.type !== 'string') {
|
|
return resolveAnchor(height, ctx)
|
|
}
|
|
switch (normalize(height.type)) {
|
|
case 'constant': return resolveAnchor(height.value, ctx)
|
|
case 'uniform': {
|
|
const min = resolveAnchor(height.min_inclusive, ctx)
|
|
const max = resolveAnchor(height.max_inclusive, ctx)
|
|
return min + ctx.nextInt(max - min + 1)
|
|
}
|
|
case 'biased_to_bottom': {
|
|
const min = resolveAnchor(height.min_inclusive, ctx)
|
|
const max = resolveAnchor(height.max_inclusive, ctx)
|
|
const n = ctx.nextInt(max - min - (height.inner ?? 1) + 1)
|
|
return min + ctx.nextInt(n + (height.inner ?? 1))
|
|
}
|
|
case 'very_biased_to_bottom': {
|
|
const min = resolveAnchor(height.min_inclusive, ctx)
|
|
const max = resolveAnchor(height.max_inclusive, ctx)
|
|
const inner = height.inner ?? 1
|
|
const n1 = min + inner + ctx.nextInt(max - min - inner + 1)
|
|
const n2 = min + ctx.nextInt(n1 - min)
|
|
return min + ctx.nextInt(n2 - min + inner)
|
|
}
|
|
case 'trapezoid': {
|
|
const min = resolveAnchor(height.min_inclusive, ctx)
|
|
const max = resolveAnchor(height.max_inclusive, ctx)
|
|
const plateau = height.plateau ?? 0
|
|
if (plateau >= max - min) {
|
|
return min + ctx.nextInt(max - min + 1)
|
|
}
|
|
const n1 = (max - min - plateau) / 2
|
|
const n2 = (max - min) - n1
|
|
return min + ctx.nextInt(n2 + 1) + ctx.nextInt(n1 + 1)
|
|
}
|
|
default: throw new Error(`Invalid height provider ${height.type}`)
|
|
}
|
|
}
|
|
|
|
// 1.17 and before
|
|
function useFeature(s: string, ctx: PlacementContext) {
|
|
const i = ctx.features.indexOf(s)
|
|
if (i != -1) return i
|
|
ctx.features.push(s)
|
|
return ctx.features.length - 1
|
|
}
|
|
|
|
function getPlacements(pos: BlockPos, feature: any, ctx: PlacementContext): void {
|
|
if (typeof feature === 'string') {
|
|
ctx.placements.push([pos, useFeature(feature, ctx)])
|
|
return
|
|
}
|
|
const type = normalize(feature?.type ?? 'no_op')
|
|
const featureFn = Features[type]
|
|
if (featureFn) {
|
|
featureFn(feature.config, pos, ctx)
|
|
} else {
|
|
ctx.placements.push([pos, useFeature(JSON.stringify(feature), ctx)])
|
|
}
|
|
}
|
|
|
|
function getPositions(pos: BlockPos, decorator: any, ctx: PlacementContext): BlockPos[] {
|
|
const type = normalize(decorator?.type ?? 'nope')
|
|
const decoratorFn = Decorators[type]
|
|
if (!decoratorFn) {
|
|
return [pos]
|
|
}
|
|
return decoratorFn(decorator?.config, pos, ctx)
|
|
}
|
|
|
|
const Features: {
|
|
[key: string]: (config: any, pos: BlockPos, ctx: PlacementContext) => void,
|
|
} = {
|
|
decorated: (config, pos, ctx) => {
|
|
const positions = getPositions(pos, config?.decorator, ctx)
|
|
positions.forEach(p => getPlacements(p, config?.feature, ctx))
|
|
},
|
|
random_boolean_selector: (config, pos, ctx) => {
|
|
const feature = ctx.nextFloat() < 0.5 ? config?.feature_true : config?.feature_false
|
|
getPlacements(pos, feature, ctx)
|
|
},
|
|
random_selector: (config, pos, ctx) => {
|
|
for (const f of config?.features ?? []) {
|
|
if (ctx.nextFloat() < (f?.chance ?? 0)) {
|
|
getPlacements(pos, f.feature, ctx)
|
|
return
|
|
}
|
|
}
|
|
getPlacements(pos, config?.default, ctx)
|
|
},
|
|
simple_random_selector: (config, pos, ctx) => {
|
|
const feature = config?.features?.[ctx.nextInt(config?.features?.length ?? 0)]
|
|
getPlacements(pos, feature, ctx)
|
|
},
|
|
}
|
|
|
|
const Decorators: {
|
|
[key: string]: (config: any, pos: BlockPos, ctx: PlacementContext) => BlockPos[],
|
|
} = {
|
|
chance: (config, pos, ctx) => {
|
|
return ctx.nextFloat() < 1 / (config?.chance ?? 1) ? [pos] : []
|
|
},
|
|
count: (config, pos, ctx) => {
|
|
return new Array(sampleInt(config?.count ?? 1, ctx)).fill(pos)
|
|
},
|
|
count_extra: (config, pos, ctx) => {
|
|
let count = config?.count ?? 1
|
|
if (ctx.nextFloat() < (config.extra_chance ?? 0)){
|
|
count += config.extra_count ?? 0
|
|
}
|
|
return new Array(count).fill(pos)
|
|
},
|
|
count_multilayer: (config, pos, ctx) => {
|
|
return new Array(sampleInt(config?.count ?? 1, ctx)).fill(pos)
|
|
.map(p => [
|
|
p[0] + ctx.nextInt(16),
|
|
p[1],
|
|
p[2] + ctx.nextInt(16),
|
|
])
|
|
},
|
|
count_noise: (config, pos, ctx) => {
|
|
const noise = ctx.biomeInfoNoise.sample(pos[0] / 200, 0, pos[2] / 200)
|
|
const count = noise < config.noise_level ? config.below_noise : config.above_noise
|
|
return new Array(count).fill(pos)
|
|
},
|
|
count_noise_biased: (config, pos, ctx) => {
|
|
const factor = Math.max(1, config.noise_factor)
|
|
const noise = ctx.biomeInfoNoise.sample(pos[0] / factor, 0, pos[2] / factor)
|
|
const count = Math.max(0, Math.ceil((noise + (config.noise_offset ?? 0)) * config.noise_to_count_ratio))
|
|
return new Array(count).fill(pos)
|
|
},
|
|
dark_oak_tree: (_config, pos, ctx) => {
|
|
return [...new Array(16)].map((_, i) => {
|
|
const x = Math.floor(i / 4) * 4 + 1 + ctx.nextInt(3) + pos[0]
|
|
const y = Math.max(ctx.seaLevel, terrain[clamp(0, 63, x)])
|
|
const z = Math.floor(i % 4) * 4 + 1 + ctx.nextInt(3) + pos[2]
|
|
return [x, y, z]
|
|
})
|
|
},
|
|
decorated: (config, pos, ctx) => {
|
|
return getPositions(pos, config?.outer, ctx).flatMap(p => {
|
|
return getPositions(p, config?.inner, ctx)
|
|
})
|
|
},
|
|
depth_average: (config, pos, ctx) => {
|
|
const y = ctx.nextInt(config?.spread ?? 0) + ctx.nextInt(config?.spread ?? 0) - (config.spread ?? 0) + (config?.baseline ?? 0)
|
|
return decorateY(pos, y)
|
|
},
|
|
emerald_ore: (_config, pos, ctx) => {
|
|
const count = 3 + ctx.nextInt(6)
|
|
return [...new Array(count)].map(() => [
|
|
pos[0] + ctx.nextInt(16),
|
|
4 + ctx.nextInt(28),
|
|
pos[2] + ctx.nextInt(16),
|
|
])
|
|
},
|
|
fire: (config, pos, ctx) => {
|
|
const count = 1 + ctx.nextInt(ctx.nextInt(sampleInt(config?.count, ctx)))
|
|
return [...new Array(count)].map(() => [
|
|
pos[0] + ctx.nextInt(16),
|
|
ctx.nextInt(128),
|
|
pos[2] + ctx.nextInt(16),
|
|
])
|
|
},
|
|
glowstone: (config, pos, ctx) => {
|
|
const count = ctx.nextInt(1 + ctx.nextInt(sampleInt(config?.count, ctx)))
|
|
return [...new Array(count)].map(() => [
|
|
pos[0] + ctx.nextInt(16),
|
|
ctx.nextInt(128),
|
|
pos[2] + ctx.nextInt(16),
|
|
])
|
|
},
|
|
heightmap: (_config, pos, ctx) => {
|
|
const y = Math.max(ctx.seaLevel, terrain[clamp(0, 63, pos[0])])
|
|
return decorateY(pos, y)
|
|
},
|
|
heightmap_spread_double: (_config, pos, ctx) => {
|
|
const y = Math.max(ctx.seaLevel, terrain[clamp(0, 63, pos[0])])
|
|
return decorateY(pos, ctx.nextInt(y * 2))
|
|
},
|
|
heightmap_world_surface: (_config, pos, ctx) => {
|
|
const y = Math.max(ctx.seaLevel, terrain[clamp(0, 63, pos[0])])
|
|
return decorateY(pos, y)
|
|
},
|
|
iceberg: (_config, pos, ctx) => {
|
|
return [[
|
|
pos[0] + 4 + ctx.nextInt(8),
|
|
pos[1],
|
|
pos[2] + 4 + ctx.nextInt(8),
|
|
]]
|
|
},
|
|
lava_lake: (config, pos, ctx) => {
|
|
if (ctx.nextInt((config.chance ?? 1) / 10) === 0) {
|
|
const y = ctx.nextInt(ctx.nextInt(256 - 8) + 8)
|
|
if (y < ctx.seaLevel || ctx.nextInt((config?.chance ?? 1) / 8) == 0) {
|
|
const x = ctx.nextInt(16) + pos[0]
|
|
const z = ctx.nextInt(16) + pos[2]
|
|
return [[x, y, z]]
|
|
}
|
|
}
|
|
return []
|
|
},
|
|
nope: (_config, pos) => {
|
|
return [pos]
|
|
},
|
|
range: (config, pos, ctx) => {
|
|
const y = ctx.nextInt((config?.maximum ?? 1) - (config?.top_offset ?? 0)) + (config?.bottom_offset ?? 0)
|
|
return decorateY(pos, y)
|
|
},
|
|
range_biased: (config, pos, ctx) => {
|
|
const y = ctx.nextInt(ctx.nextInt((config?.maximum ?? 1) - (config?.top_offset ?? 0)) + (config?.bottom_offset ?? 0))
|
|
return decorateY(pos, y)
|
|
},
|
|
range_very_biased: (config, pos, ctx) => {
|
|
const y = ctx.nextInt(ctx.nextInt(ctx.nextInt((config?.maximum ?? 1) - (config?.top_offset ?? 0)) + (config?.bottom_offset ?? 0)) + (config?.bottom_offset ?? 0))
|
|
return decorateY(pos, y)
|
|
},
|
|
spread_32_above: (_config, pos, ctx) => {
|
|
const y = ctx.nextInt(pos[1] + 32)
|
|
return decorateY(pos, y)
|
|
},
|
|
top_solid_heightmap: (_config, pos) => {
|
|
const y = terrain[clamp(0, 63, pos[0])]
|
|
return decorateY(pos, y)
|
|
},
|
|
magma: (_config, pos, ctx) => {
|
|
const y = ctx.nextInt(pos[1] + 32)
|
|
return decorateY(pos, y)
|
|
},
|
|
square: (_config, pos, ctx) => {
|
|
return [[
|
|
pos[0] + ctx.nextInt(16),
|
|
pos[1],
|
|
pos[2] + ctx.nextInt(16),
|
|
]]
|
|
},
|
|
surface_relative_threshold: (config, pos) => {
|
|
const height = terrain[clamp(0, 63, pos[0])]
|
|
const min = height + (config?.min_inclusive ?? -Infinity)
|
|
const max = height + (config?.max_inclusive ?? Infinity)
|
|
return (pos[1] < min || pos[1] > max) ? [pos] : []
|
|
},
|
|
water_lake: (config, pos, ctx) => {
|
|
if (ctx.nextInt(config.chance ?? 1) === 0) {
|
|
return [[
|
|
pos[0] + ctx.nextInt(16),
|
|
ctx.nextInt(256),
|
|
pos[2] + ctx.nextInt(16),
|
|
]]
|
|
}
|
|
return []
|
|
},
|
|
}
|
|
|
|
// 1.18 and after
|
|
function modifyPlacement(pos: BlockPos, placement: any[], ctx: PlacementContext) {
|
|
let positions = [pos]
|
|
for (const modifier of placement) {
|
|
const modifierFn = PlacementModifiers[normalize(modifier?.type ?? 'nope')]
|
|
if (!modifierFn) continue
|
|
positions = positions.flatMap(pos =>
|
|
PlacementModifiers[normalize(modifier.type)](modifier, pos, ctx)
|
|
)
|
|
}
|
|
for (const pos of positions) {
|
|
ctx.placements.push([pos, 0])
|
|
}
|
|
}
|
|
|
|
const PlacementModifiers: {
|
|
[key: string]: (config: any, pos: BlockPos, ctx: PlacementContext) => BlockPos[],
|
|
} = {
|
|
count: ({ count }, pos, ctx) => {
|
|
return new Array(sampleInt(count ?? 1, ctx)).fill(pos)
|
|
},
|
|
count_on_every_layer: ({ count }, pos, ctx) => {
|
|
return new Array(sampleInt(count ?? 1, ctx)).fill(pos)
|
|
.map(p => [
|
|
p[0] + ctx.nextInt(16),
|
|
p[1],
|
|
p[2] + ctx.nextInt(16),
|
|
])
|
|
},
|
|
environment_scan: ({}, pos) => {
|
|
return [pos]
|
|
},
|
|
height_range: ({ height }, pos, ctx) => {
|
|
return decorateY(pos, sampleHeight(height, ctx))
|
|
},
|
|
heightmap: ({}, pos, ctx) => {
|
|
const y = Math.max(ctx.seaLevel, terrain[clamp(0, 63, pos[0])])
|
|
return decorateY(pos, y)
|
|
},
|
|
in_square: ({}, pos, ctx) => {
|
|
return [[
|
|
pos[0] + ctx.nextInt(16),
|
|
pos[1],
|
|
pos[2] + ctx.nextInt(16),
|
|
]]
|
|
},
|
|
noise_based_count: ({ noise_to_count_ratio, noise_factor, noise_offset }, pos, ctx) => {
|
|
const factor = Math.max(1, noise_factor)
|
|
const noise = ctx.biomeInfoNoise.sample(pos[0] / factor, 0, pos[2] / factor)
|
|
const count = Math.max(0, Math.ceil((noise + (noise_offset ?? 0)) * noise_to_count_ratio))
|
|
return new Array(count).fill(pos)
|
|
},
|
|
noise_threshold_count: ({ noise_level, below_noise, above_noise }, pos, ctx) => {
|
|
const noise = ctx.biomeInfoNoise.sample(pos[0] / 200, 0, pos[2] / 200)
|
|
const count = noise < noise_level ? below_noise : above_noise
|
|
return new Array(count).fill(pos)
|
|
},
|
|
random_offset: ({ xz_spread, y_spread }, pos, ctx) => {
|
|
return [[
|
|
pos[0] + sampleInt(xz_spread, ctx),
|
|
pos[1] + sampleInt(y_spread, ctx),
|
|
pos[2] + sampleInt(xz_spread, ctx),
|
|
]]
|
|
},
|
|
rarity_filter: ({ chance }, pos, ctx) => {
|
|
return ctx.nextFloat() < 1 / (chance ?? 1) ? [pos] : []
|
|
},
|
|
}
|