95 lines
3 KiB
TypeScript
95 lines
3 KiB
TypeScript
import type { NoiseFunction2D } from 'simplex-noise'
|
|
import { blockTypes as T, level as L, probability as P } from './def'
|
|
import type { Block } from '../types.d'
|
|
|
|
function trees(r: number, i: number, row: Block[], previousRow: Block[]) {
|
|
const max = row.length - 1
|
|
const h = i - 1
|
|
const j = i + 1
|
|
const current = row[i]
|
|
const above = previousRow[i]
|
|
const aboveLeft = previousRow[h]
|
|
const aboveRight = previousRow[j]
|
|
|
|
if (current === T.treeCrown) {
|
|
if (i > 0) row[h] = T.treeLeaves
|
|
if (i < max) row[j] = T.treeLeaves
|
|
|
|
} else if (above === T.treeCrown) {
|
|
row[i] = T.treeLeaves
|
|
if (i > 0) row[h] = T.treeLeaves
|
|
if (i < max) row[j] = T.treeLeaves
|
|
|
|
} else if (above === T.treeLeaves && aboveLeft === T.treeLeaves && aboveRight === T.treeLeaves) {
|
|
row[i] = T.treeTrunk
|
|
if (i > 0) row[h] = T.treeLeaves
|
|
if (i < max) row[j] = T.treeLeaves
|
|
|
|
} else if (above === T.treeTrunk) {
|
|
if (current === T.air) row[i] = T.treeTrunk
|
|
else row[i] = T.treeRoot
|
|
} else if (above === T.treeRoot) {
|
|
row[i] = T.soil
|
|
if (i > 0) row[h] = T.treeRoot
|
|
if (i < max) row[j] = T.treeRoot
|
|
}
|
|
}
|
|
|
|
function ground(r: number, i: number, current: Block, above: Block) {
|
|
if (above === T.air) {
|
|
if (r < P.soilHole) return T.air
|
|
if (current === T.soil) return T.grass
|
|
}
|
|
return current
|
|
}
|
|
|
|
/*
|
|
function ground(r: number, i: number, row: Block[], previousRow: Block[]) {
|
|
const rootParts = [T.treeRootLeft, T.treeRootMiddle, T.treeRootRight]
|
|
const prevBlock = previousRow[i]
|
|
|
|
if (prevBlock === T.air) {
|
|
if (r < P.soilHole) row[i] = T.air
|
|
else if (row[i] === T.soil) row[i] = T.grass
|
|
} else if (rootParts.indexOf(prevBlock) >= 0) {
|
|
if (row[i] === T.soil) row[i] = T.grass
|
|
}
|
|
}
|
|
*/
|
|
|
|
function rock(r: number, i: number, current: Block, above: Block) {
|
|
if (above === T.soil && r < P.fray) return T.soil
|
|
return current
|
|
}
|
|
|
|
function underground(r: number, i: number, current: Block, above: Block) {
|
|
if (above === T.stone && r < P.fray) return T.stone
|
|
return current
|
|
}
|
|
|
|
export default function createBlockExtender(rand: NoiseFunction2D) {
|
|
function growTrees(level: number, column: number, offset: number, row: Block[], previousRow: Block[]) {
|
|
const r = rand(level, column + offset)
|
|
trees(r, column, row, previousRow)
|
|
}
|
|
|
|
function extendBlock(level: number, column: number, offset: number, current: Block, above: Block) {
|
|
const r = rand(level, column + offset)
|
|
|
|
if (level < L.rock) return ground(r, column, current, above)
|
|
if (level < L.underground) return rock(r, column, current, above)
|
|
return underground(r, column, current, above)
|
|
}
|
|
|
|
function extendRow(level: number, columnOffset: number, row: Block[], previousRow: Block[]) {
|
|
for (let column = 0; column < row.length; column++) {
|
|
if (level < L.ground) {
|
|
// growTrees(level, column, columnOffset, row, previousRow)
|
|
} else {
|
|
row[column] = extendBlock(level, column, columnOffset, row[column], previousRow[column])
|
|
}
|
|
}
|
|
}
|
|
|
|
return { extendBlock, extendRow }
|
|
}
|