Add world generator sources and binary
This commit is contained in:
chelsea
709
mc.py
Normal file
709
mc.py
Normal file
@@ -0,0 +1,709 @@
|
||||
import math
|
||||
import random
|
||||
from opensimplex import OpenSimplex # OpenSimplex noise for smooth, terrain-like variation
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# BASIC WORLD CONSTANTS
|
||||
# ---------------------------------------------------------------------------
|
||||
# Approximate water surface level (everything below may become ocean/lake)
|
||||
sea_level = 70
|
||||
# World seed: change this to get a completely different world layout,
|
||||
# but the same seed always produces the same terrain.
|
||||
world_seed = 123456
|
||||
# Create a global OpenSimplex noise generator.
|
||||
# This object gives us deterministic noise values from coordinates + seed.
|
||||
noise = OpenSimplex(world_seed)
|
||||
# Cache column heights so repeated lookups (like water detection) stay cheap.
|
||||
_height_cache = {}
|
||||
# Cache derived column data (height + water surface) so generateBlock doesn't
|
||||
# recompute expensive basin detection for every y in the same column.
|
||||
_column_data_cache = {}
|
||||
# Base biome temperatures (you already had this)
|
||||
biome_base_temps = {
|
||||
"desert": 110,
|
||||
"plains": 80,
|
||||
"plains_river": 80,
|
||||
"rolling_hills": 75,
|
||||
}
|
||||
# Map block "names" to numeric IDs.
|
||||
# These IDs are what your engine or save format actually uses internally.
|
||||
# You can change these numbers to match your own block registry.
|
||||
block_ids = {
|
||||
"bedrock": 0,
|
||||
"stone": 1,
|
||||
"dirt": 2,
|
||||
"grass": 3,
|
||||
"water": 4,
|
||||
"air": 5,
|
||||
"oak_log": 6,
|
||||
"oak_leaves": 7,
|
||||
"birch_log": 8,
|
||||
"birch_leaves": 9,
|
||||
"coal": 10,
|
||||
}
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# ORE GENERATION
|
||||
# ---------------------------------------------------------------------------
|
||||
class OreGeneration:
|
||||
"""Namespace for all ore generation systems"""
|
||||
|
||||
class CoalSeams:
|
||||
"""Coal seam generation - each seam type is independent and combinable"""
|
||||
|
||||
# --- Atomic Helper Functions ---
|
||||
|
||||
@staticmethod
|
||||
def _check_point_in_seam(y, seam_center, half_thickness):
|
||||
"""Atomic: Check if y coordinate is within seam vertical bounds"""
|
||||
return abs(y - seam_center) <= half_thickness
|
||||
|
||||
@staticmethod
|
||||
def _calculate_seam_offset(x, y, z, scale=0.02, amplitude=2.0):
|
||||
"""Atomic: Calculate vertical offset for seam undulation using 3D noise"""
|
||||
return noise.noise3(x * scale, y * scale, z * scale) * amplitude
|
||||
|
||||
@staticmethod
|
||||
def _calculate_thickness_variation(x, z, scale=0.03, amplitude=1.0):
|
||||
"""Atomic: Calculate thickness variation across horizontal plane using 2D noise"""
|
||||
return noise.noise2(x * scale, z * scale) * amplitude
|
||||
|
||||
@staticmethod
|
||||
def _check_seam_continuity(x, y, z, threshold=-0.7):
|
||||
"""Atomic: Determine if seam is solid or pinched out at this point"""
|
||||
continuity_noise = noise.noise3(x * 0.05, y * 0.05, z * 0.05)
|
||||
return continuity_noise > threshold
|
||||
|
||||
@staticmethod
|
||||
def _check_seam(x, y, z, center, thickness, undulation_scale=0.02, undulation_amp=2.0,
|
||||
thickness_scale=0.03, thickness_amp=1.0, continuity_threshold=-0.7):
|
||||
"""
|
||||
Generic seam checker - all seam types use this.
|
||||
|
||||
Args:
|
||||
center: Base y-level for seam center
|
||||
thickness: Base thickness in blocks
|
||||
undulation_scale/amp: Control vertical wave pattern
|
||||
thickness_scale/amp: Control horizontal thickness variation
|
||||
continuity_threshold: Controls gap frequency (higher = fewer gaps)
|
||||
"""
|
||||
seam_offset = OreGeneration.CoalSeams._calculate_seam_offset(x, y, z, undulation_scale, undulation_amp)
|
||||
adjusted_center = center + seam_offset
|
||||
|
||||
thickness_variation = OreGeneration.CoalSeams._calculate_thickness_variation(x, z, thickness_scale, thickness_amp)
|
||||
adjusted_thickness = thickness + thickness_variation
|
||||
half_thickness = adjusted_thickness / 2.0
|
||||
|
||||
if OreGeneration.CoalSeams._check_point_in_seam(y, adjusted_center, half_thickness):
|
||||
if OreGeneration.CoalSeams._check_seam_continuity(x, y, z, continuity_threshold):
|
||||
return True
|
||||
return False
|
||||
|
||||
@staticmethod
|
||||
def _check_flat_ceiling_seam(x, y, z, column_height, ceiling_depth, thickness,
|
||||
thickness_scale=0.03, thickness_amp=1.0, continuity_threshold=-0.7):
|
||||
"""
|
||||
Check for seam with flat ceiling and flat floor (strip mining incentive).
|
||||
|
||||
Geometry:
|
||||
- Ceiling (top): flat at column_height - ceiling_depth
|
||||
- Floor (bottom): flat at column_height - ceiling_depth - thickness
|
||||
- Ore exposure: wavy top surface via continuity check
|
||||
|
||||
Args:
|
||||
column_height: Terrain surface height at this x,z
|
||||
ceiling_depth: Fixed depth below surface for seam ceiling
|
||||
thickness: Fixed thickness in blocks (no variation)
|
||||
thickness_scale/amp: Unused (kept for compatibility)
|
||||
continuity_threshold: Controls gap frequency (higher = fewer gaps)
|
||||
"""
|
||||
seam_ceiling = column_height - ceiling_depth
|
||||
seam_floor = seam_ceiling - thickness
|
||||
|
||||
if seam_floor <= y <= seam_ceiling:
|
||||
if OreGeneration.CoalSeams._check_seam_continuity(x, y, z, continuity_threshold):
|
||||
return True
|
||||
return False
|
||||
|
||||
@staticmethod
|
||||
def _check_terrain_relative_seam(x, y, z, column_height, depth_below_surface, thickness,
|
||||
thickness_scale=0.03, thickness_amp=1.0, continuity_threshold=-0.7):
|
||||
"""
|
||||
Check for seam at fixed depth below terrain surface (perfect for strip mining).
|
||||
|
||||
Args:
|
||||
column_height: The terrain surface height at this x,z
|
||||
depth_below_surface: How many blocks below surface the seam center is
|
||||
thickness: Base thickness in blocks
|
||||
thickness_scale/amp: Control horizontal thickness variation
|
||||
continuity_threshold: Controls gap frequency (higher = fewer gaps)
|
||||
"""
|
||||
# Seam follows terrain - always at same depth below surface
|
||||
seam_center = column_height - depth_below_surface
|
||||
|
||||
thickness_variation = OreGeneration.CoalSeams._calculate_thickness_variation(x, z, thickness_scale, thickness_amp)
|
||||
adjusted_thickness = thickness + thickness_variation
|
||||
half_thickness = adjusted_thickness / 2.0
|
||||
|
||||
if OreGeneration.CoalSeams._check_point_in_seam(y, seam_center, half_thickness):
|
||||
if OreGeneration.CoalSeams._check_seam_continuity(x, y, z, continuity_threshold):
|
||||
return True
|
||||
return False
|
||||
|
||||
# --- Individual Seam Types (Combinable) ---
|
||||
|
||||
@staticmethod
|
||||
def deep_seam(x, y, z):
|
||||
"""Deep seam (y=10-15): 5 blocks thick, for room-and-pillar underground mining"""
|
||||
return OreGeneration.CoalSeams._check_seam(x, y, z, center=12, thickness=5)
|
||||
|
||||
@staticmethod
|
||||
def medium_seam(x, y, z):
|
||||
"""Medium seam (y=30-35): 4 blocks thick, standard underground mining depth"""
|
||||
return OreGeneration.CoalSeams._check_seam(x, y, z, center=32, thickness=4)
|
||||
|
||||
@staticmethod
|
||||
def shallow_mountain_seam(x, y, z):
|
||||
"""Shallow seam (y=80-90): 3 blocks thick, exposed on mountains for strip/MTR mining"""
|
||||
return OreGeneration.CoalSeams._check_seam(x, y, z, center=85, thickness=3)
|
||||
|
||||
@staticmethod
|
||||
def shallow_plains_seam(x, y, z):
|
||||
"""Shallow plains seam (y=45): 2 blocks thick, less undulation"""
|
||||
return OreGeneration.CoalSeams._check_seam(
|
||||
x, y, z, center=45, thickness=2,
|
||||
undulation_scale=0.015, undulation_amp=1.5,
|
||||
thickness_scale=0.04, thickness_amp=0.5,
|
||||
continuity_threshold=-0.6 # More continuous
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def medium_plains_seam(x, y, z):
|
||||
"""Medium plains seam (y=25): 3 blocks thick, less undulation"""
|
||||
return OreGeneration.CoalSeams._check_seam(
|
||||
x, y, z, center=25, thickness=3,
|
||||
undulation_scale=0.015, undulation_amp=1.5,
|
||||
thickness_scale=0.04, thickness_amp=0.5,
|
||||
continuity_threshold=-0.6 # More continuous
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def surface_strip_seam(x, y, z, column_height):
|
||||
"""
|
||||
Strip mining seam with flat ceiling at column_height - 5.
|
||||
West Kentucky accurate: 1 block thick, highly continuous.
|
||||
Incentivizes leveling terrain to access the ore layer.
|
||||
"""
|
||||
return OreGeneration.CoalSeams._check_flat_ceiling_seam(
|
||||
x, y, z, column_height,
|
||||
ceiling_depth=5,
|
||||
thickness=1,
|
||||
thickness_scale=0.02,
|
||||
thickness_amp=0.3,
|
||||
continuity_threshold=-0.3 # Very high continuity, fewer gaps
|
||||
)
|
||||
|
||||
# --- Biome Configurations (which seams are active) ---
|
||||
|
||||
BIOME_SEAMS = {
|
||||
"appalachian": ["deep_seam", "medium_seam", "shallow_mountain_seam", "surface_strip_seam"],
|
||||
"plains": ["medium_plains_seam", "shallow_plains_seam", "surface_strip_seam"],
|
||||
"desert": ["deep_seam"], # Only deep seams in desert
|
||||
"mixed": ["deep_seam", "medium_seam", "medium_plains_seam", "surface_strip_seam"],
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def generate_coal(x, y, z, column_height=None, biome="appalachian"):
|
||||
"""
|
||||
Main entry point for coal generation.
|
||||
Checks all seam types active for the given biome.
|
||||
|
||||
Args:
|
||||
x, y, z: Block coordinates
|
||||
column_height: Terrain surface height (needed for terrain-relative seams)
|
||||
biome: Biome name (e.g., "appalachian", "plains", "desert")
|
||||
|
||||
Returns:
|
||||
True if coal should be placed at this location, False otherwise
|
||||
"""
|
||||
# Get seam types for this biome (default to appalachian)
|
||||
seam_types = OreGeneration.CoalSeams.BIOME_SEAMS.get(biome, ["deep_seam", "medium_seam", "shallow_mountain_seam", "surface_strip_seam"])
|
||||
|
||||
# Check each active seam type
|
||||
for seam_name in seam_types:
|
||||
seam_func = getattr(OreGeneration.CoalSeams, seam_name, None)
|
||||
if seam_func:
|
||||
# Handle terrain-relative seams that need column_height
|
||||
if seam_name == "surface_strip_seam":
|
||||
if column_height is not None and seam_func(x, y, z, column_height):
|
||||
return True
|
||||
else:
|
||||
# Standard fixed-depth seams
|
||||
if seam_func(x, y, z):
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# WORLD GENERATION
|
||||
# ---------------------------------------------------------------------------
|
||||
class worldGen:
|
||||
# minimum bowl depth needed before we consider it a lake candidate
|
||||
BASIN_MIN_DEPTH = 4
|
||||
# how far around a column we scan to estimate its bowl rim
|
||||
BASIN_RADIUS = 4
|
||||
# Tree placement tuning
|
||||
TREE_GRID_SPACING = 6 # coarse grid to enforce spacing
|
||||
TREE_MARGIN = 3 # how far outside the chunk we look for trunks (so crowns don't cut off)
|
||||
MIN_TREE_ALT = sea_level - 2
|
||||
LOW_FADE_TOP = sea_level + 6
|
||||
TREE_LINE = sea_level + 60
|
||||
TREE_LINE_FADE = 20
|
||||
MAX_SLOPE = 2
|
||||
|
||||
@staticmethod
|
||||
def getBlockID(block_name: str) -> int:
|
||||
"""
|
||||
Convert a human-readable block name (e.g. "grass") into a numeric ID.
|
||||
If the name isn't found, we default to "air" so we don't crash.
|
||||
In a real engine, you'd probably want to raise an error instead.
|
||||
"""
|
||||
return block_ids.get(block_name, block_ids["air"])
|
||||
|
||||
@staticmethod
|
||||
def _get_column_height(x: int, z: int) -> int:
|
||||
key = (x, z)
|
||||
if key in _height_cache:
|
||||
return _height_cache[key]
|
||||
|
||||
# DOMAIN WARPING - Keep this the same
|
||||
warp1_x = x + noise.noise2(x * 0.001, z * 0.001) * 50
|
||||
warp1_z = z + noise.noise2((x+1000) * 0.001, (z+1000) * 0.001) * 50
|
||||
|
||||
warp2_x = warp1_x + noise.noise2(warp1_x * 0.01, warp1_z * 0.01) * 10
|
||||
warp2_z = warp1_z + noise.noise2((warp1_x+500) * 0.01, (warp1_z+500) * 0.01) * 10
|
||||
base_height = sea_level - 5
|
||||
|
||||
height = base_height
|
||||
|
||||
# KEEP THESE - Large scale features (mountains, valleys)
|
||||
height += noise.noise2(warp2_x * 0.0005, warp2_z * 0.0005) * 80
|
||||
height += noise.noise2(warp2_x * 0.002, warp2_z * 0.002) * 40
|
||||
height += noise.noise2(warp2_x * 0.005, warp2_z * 0.005) * 25
|
||||
height += noise.noise2(warp2_x * 0.01, warp2_z * 0.01) * 15
|
||||
|
||||
# REDUCE OR REMOVE THESE - Small scale bumps and roughness
|
||||
height += noise.noise2(warp2_x * 0.02, warp2_z * 0.02) * 5 # Was 10
|
||||
height += noise.noise2(warp2_x * 0.05, warp2_z * 0.05) * 2 # Was 6
|
||||
height += noise.noise2(warp2_x * 0.1, warp2_z * 0.1) * 1 # Was 3
|
||||
# height += noise.noise2(warp2_x * 0.2, warp2_z * 0.2) * 1 # REMOVE - too rough
|
||||
|
||||
_height_cache[key] = int(height)
|
||||
return int(height)
|
||||
|
||||
|
||||
@staticmethod
|
||||
def _estimate_basin_water_surface(x: int, z: int, column_height: int):
|
||||
"""Look for local bowls and return a rim height if one exists."""
|
||||
samples = []
|
||||
for dx in range(-worldGen.BASIN_RADIUS, worldGen.BASIN_RADIUS + 1):
|
||||
for dz in range(-worldGen.BASIN_RADIUS, worldGen.BASIN_RADIUS + 1):
|
||||
if dx == 0 and dz == 0:
|
||||
continue
|
||||
samples.append(worldGen._get_column_height(x + dx, z + dz))
|
||||
if not samples:
|
||||
return None
|
||||
rim_height = min(samples)
|
||||
if rim_height - column_height < worldGen.BASIN_MIN_DEPTH:
|
||||
return None
|
||||
return rim_height
|
||||
|
||||
@staticmethod
|
||||
def _get_column_data(x: int, z: int):
|
||||
key = (x, z)
|
||||
cached = _column_data_cache.get(key)
|
||||
if cached:
|
||||
return cached
|
||||
column_height = worldGen._get_column_height(x, z)
|
||||
basin_surface = worldGen._estimate_basin_water_surface(x, z, column_height)
|
||||
if basin_surface is not None:
|
||||
water_surface_y = basin_surface
|
||||
elif column_height < sea_level:
|
||||
water_surface_y = sea_level
|
||||
else:
|
||||
water_surface_y = None
|
||||
data = (column_height, water_surface_y)
|
||||
_column_data_cache[key] = data
|
||||
return data
|
||||
|
||||
@staticmethod
|
||||
def generateBlock(x: int, y: int, z: int) -> int:
|
||||
"""
|
||||
Determine which block ID should exist at world coordinates (x, y, z).
|
||||
This uses:
|
||||
- A noise-based heightmap (via OpenSimplex) to decide terrain surface.
|
||||
- Simple layering rules for stone/dirt/grass.
|
||||
- sea_level to decide where water goes.
|
||||
"""
|
||||
# -------------------------------------------------------------------
|
||||
# 1. BEDROCK LAYER
|
||||
# -------------------------------------------------------------------
|
||||
# We force a solid bedrock floor at the bottom of the world.
|
||||
# You can change "0" to something else if you want a thicker bedrock band.
|
||||
if y == 0:
|
||||
return worldGen.getBlockID("bedrock")
|
||||
# -------------------------------------------------------------------
|
||||
# 2. TERRAIN HEIGHT FOR THIS (x, z) COLUMN
|
||||
# -------------------------------------------------------------------
|
||||
column_height, water_surface_y = worldGen._get_column_data(x, z)
|
||||
# -------------------------------------------------------------------
|
||||
# 3. WATER LEVEL LOGIC
|
||||
# -------------------------------------------------------------------
|
||||
# First, try finding a local bowl and fill it to the rim. If no bowl
|
||||
# exists, fall back to the global sea_level rule for oceans.
|
||||
# (handled inside _get_column_data now)
|
||||
# -------------------------------------------------------------------
|
||||
# 4. BLOCK SELECTION BY VERTICAL POSITION
|
||||
# -------------------------------------------------------------------
|
||||
# We now choose the block type based on how y compares to:
|
||||
# - column_height (terrain surface)
|
||||
# - water_surface_y (ocean/lake surface)
|
||||
#
|
||||
# Basic layering:
|
||||
# - Bedrock at y <= 0 (we already handled this above)
|
||||
# - From y=1 up to terrain surface - 4: stone
|
||||
# - Next 3 layers under the surface: dirt
|
||||
# - Surface: grass (if above water), or sand/etc. if you add biomes later
|
||||
# - Between terrain surface and water surface: water
|
||||
# - Above water surface: air
|
||||
# 4a. Terrain below the ground surface => underground blocks
|
||||
if y < column_height - 3:
|
||||
# Check for coal seams first (pass column_height for terrain-relative seams)
|
||||
if OreGeneration.generate_coal(x, y, z, column_height=column_height, biome="appalachian"):
|
||||
return worldGen.getBlockID("coal")
|
||||
# Deep underground: solid stone
|
||||
return worldGen.getBlockID("stone")
|
||||
if y < column_height:
|
||||
# Just under the surface: a few layers of dirt
|
||||
return worldGen.getBlockID("dirt")
|
||||
# 4b. Exactly at the terrain surface
|
||||
if y == column_height:
|
||||
# If this position is also *below* sea level, we might prefer sand or
|
||||
# some other block later depending on biome and proximity to water.
|
||||
# For now, always grass as your basic "land" surface.
|
||||
return worldGen.getBlockID("grass")
|
||||
# 4c. Above the terrain surface but below water surface => water column
|
||||
if water_surface_y is not None and y <= water_surface_y and y > column_height:
|
||||
# This is underwater. A simple ocean/lake fill.
|
||||
return worldGen.getBlockID("water")
|
||||
# 4d. Everything else is air
|
||||
return worldGen.getBlockID("air")
|
||||
|
||||
@staticmethod
|
||||
def _can_place_tree(x: int, y: int, z: int, height: int) -> bool:
|
||||
"""
|
||||
Check if there's enough space to place a tree.
|
||||
- Must be on grass block
|
||||
- Must have air above for tree height + crown
|
||||
"""
|
||||
ground_block = worldGen.generateBlock(x, y - 1, z)
|
||||
if ground_block != worldGen.getBlockID("grass"):
|
||||
return False
|
||||
for check_y in range(y, y + height + 3):
|
||||
if worldGen.generateBlock(x, check_y, z) != worldGen.getBlockID("air"):
|
||||
return False
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def _tree_density_mask(x: int, z: int) -> float:
|
||||
"""Blend two low-frequency noises to drive forest clumping."""
|
||||
forest = noise.noise2((x + 3000) * 0.01, (z - 3000) * 0.01)
|
||||
moisture = noise.noise2((x - 5000) * 0.02, (z + 5000) * 0.02)
|
||||
return (forest * 0.6 + moisture * 0.4 + 1.0) * 0.5 # normalize to ~0..1
|
||||
|
||||
@staticmethod
|
||||
def _ground_slope(x: int, z: int) -> int:
|
||||
center = worldGen._get_column_height(x, z)
|
||||
max_delta = 0
|
||||
for dx, dz in ((1, 0), (-1, 0), (0, 1), (0, -1)):
|
||||
neighbor = worldGen._get_column_height(x + dx, z + dz)
|
||||
max_delta = max(max_delta, abs(neighbor - center))
|
||||
return max_delta
|
||||
|
||||
@staticmethod
|
||||
def _generate_oak_tree(x: int, y: int, z: int, variation: int = 0, rng: random.Random = None):
|
||||
"""
|
||||
Generate an oak tree structure.
|
||||
Returns a list of (x, y, z, block_id) tuples.
|
||||
|
||||
variation: 0-2 for small/medium/large trees
|
||||
"""
|
||||
if rng is None:
|
||||
rng = random
|
||||
blocks = []
|
||||
log_id = worldGen.getBlockID("oak_log")
|
||||
leaf_id = worldGen.getBlockID("oak_leaves")
|
||||
trunk_height = 4 + variation + rng.randint(0, 2)
|
||||
# Build trunk
|
||||
for dy in range(trunk_height):
|
||||
blocks.append((x, y + dy, z, log_id))
|
||||
# Crown starting height
|
||||
crown_start = y + trunk_height - 2
|
||||
crown_top = y + trunk_height + 2
|
||||
# Build leaf crown (roughly spherical)
|
||||
for cy in range(crown_start, crown_top):
|
||||
distance_from_center = abs(cy - (crown_start + 2))
|
||||
if distance_from_center == 0:
|
||||
radius = 2
|
||||
elif distance_from_center == 1:
|
||||
radius = 2
|
||||
elif distance_from_center == 2:
|
||||
radius = 1
|
||||
else:
|
||||
radius = 1
|
||||
# Place leaves in a circle
|
||||
for dx in range(-radius, radius + 1):
|
||||
for dz in range(-radius, radius + 1):
|
||||
if abs(dx) == radius and abs(dz) == radius:
|
||||
if rng.random() > 0.3:
|
||||
continue
|
||||
if dx == 0 and dz == 0 and cy < y + trunk_height:
|
||||
continue
|
||||
blocks.append((x + dx, cy, z + dz, leaf_id))
|
||||
return blocks
|
||||
|
||||
@staticmethod
|
||||
def _generate_birch_tree(x: int, y: int, z: int, rng: random.Random = None):
|
||||
"""
|
||||
Generate a birch tree structure (taller, thinner than oak).
|
||||
Returns a list of (x, y, z, block_id) tuples.
|
||||
"""
|
||||
if rng is None:
|
||||
rng = random
|
||||
blocks = []
|
||||
log_id = worldGen.getBlockID("birch_log")
|
||||
leaf_id = worldGen.getBlockID("birch_leaves")
|
||||
trunk_height = 5 + rng.randint(0, 3)
|
||||
# Build trunk
|
||||
for dy in range(trunk_height):
|
||||
blocks.append((x, y + dy, z, log_id))
|
||||
# Smaller, higher crown
|
||||
crown_start = y + trunk_height - 1
|
||||
crown_top = y + trunk_height + 2
|
||||
for cy in range(crown_start, crown_top):
|
||||
distance_from_top = crown_top - cy
|
||||
if distance_from_top <= 1:
|
||||
radius = 1
|
||||
else:
|
||||
radius = 2
|
||||
for dx in range(-radius, radius + 1):
|
||||
for dz in range(-radius, radius + 1):
|
||||
if abs(dx) + abs(dz) > radius + 1:
|
||||
continue
|
||||
if dx == 0 and dz == 0 and cy < y + trunk_height:
|
||||
continue
|
||||
blocks.append((x + dx, cy, z + dz, leaf_id))
|
||||
return blocks
|
||||
|
||||
@staticmethod
|
||||
def generateTree(x: int, y: int, z: int, tree_type: str = "oak", variation: int = None, rng: random.Random = None):
|
||||
"""
|
||||
Main tree generation function.
|
||||
|
||||
Args:
|
||||
x, y, z: Base coordinates for tree trunk
|
||||
tree_type: "oak" or "birch"
|
||||
variation: For oak trees, 0-2 for size variation
|
||||
rng: optional random.Random for deterministic per-tree variation
|
||||
|
||||
Returns:
|
||||
List of (x, y, z, block_id) tuples, or None if can't place
|
||||
"""
|
||||
if rng is None:
|
||||
rng = random
|
||||
if tree_type == "oak":
|
||||
if variation is None:
|
||||
variation = rng.randint(0, 2)
|
||||
if not worldGen._can_place_tree(x, y, z, 4 + variation):
|
||||
return None
|
||||
return worldGen._generate_oak_tree(x, y, z, variation, rng)
|
||||
elif tree_type == "birch":
|
||||
if not worldGen._can_place_tree(x, y, z, 6):
|
||||
return None
|
||||
return worldGen._generate_birch_tree(x, y, z, rng)
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def generate_chunk_trees(chunk_x: int, chunk_z: int):
|
||||
"""
|
||||
Populate trees for a chunk (including a small margin so crowns don't cut off).
|
||||
Returns a dict keyed by (x, y, z) with block IDs to overlay on terrain.
|
||||
"""
|
||||
tree_blocks = {}
|
||||
grid = worldGen.TREE_GRID_SPACING
|
||||
margin = worldGen.TREE_MARGIN
|
||||
chunk_min_x = chunk_x * 16 - margin
|
||||
chunk_max_x = chunk_min_x + 16 + 2 * margin - 1
|
||||
chunk_min_z = chunk_z * 16 - margin
|
||||
chunk_max_z = chunk_min_z + 16 + 2 * margin - 1
|
||||
|
||||
grid_min_x = math.floor(chunk_min_x / grid)
|
||||
grid_max_x = math.floor(chunk_max_x / grid)
|
||||
grid_min_z = math.floor(chunk_min_z / grid)
|
||||
grid_max_z = math.floor(chunk_max_z / grid)
|
||||
|
||||
for gx in range(grid_min_x, grid_max_x + 1):
|
||||
for gz in range(grid_min_z, grid_max_z + 1):
|
||||
rng = random.Random(world_seed + gx * 341873128712 + gz * 132897987541)
|
||||
candidate_x = gx * grid + rng.randint(0, grid - 1)
|
||||
candidate_z = gz * grid + rng.randint(0, grid - 1)
|
||||
# Only consider trunks that could affect this chunk (with margin)
|
||||
if not (chunk_min_x <= candidate_x <= chunk_max_x and chunk_min_z <= candidate_z <= chunk_max_z):
|
||||
continue
|
||||
|
||||
column_height, water_surface_y = worldGen._get_column_data(candidate_x, candidate_z)
|
||||
# Avoid underwater or flooded tiles
|
||||
if water_surface_y is not None and column_height < water_surface_y:
|
||||
continue
|
||||
# Elevation gates
|
||||
if column_height < worldGen.MIN_TREE_ALT or column_height > worldGen.TREE_LINE:
|
||||
continue
|
||||
# Slope gate to keep cliffs and sharp ridges clear
|
||||
if worldGen._ground_slope(candidate_x, candidate_z) > worldGen.MAX_SLOPE:
|
||||
continue
|
||||
|
||||
altitude_factor = 1.0
|
||||
# Fade near shore/marsh
|
||||
if column_height < worldGen.LOW_FADE_TOP:
|
||||
fade_span = max(1, worldGen.LOW_FADE_TOP - worldGen.MIN_TREE_ALT)
|
||||
altitude_factor *= max(0.0, (column_height - worldGen.MIN_TREE_ALT) / fade_span)
|
||||
# Fade near tree line
|
||||
if column_height > worldGen.TREE_LINE - worldGen.TREE_LINE_FADE:
|
||||
altitude_factor *= max(0.0, (worldGen.TREE_LINE - column_height) / worldGen.TREE_LINE_FADE)
|
||||
if altitude_factor <= 0:
|
||||
continue
|
||||
|
||||
density = worldGen._tree_density_mask(candidate_x, candidate_z)
|
||||
base_prob = 0.5
|
||||
spawn_prob = base_prob * (0.6 + 0.4 * density) * altitude_factor
|
||||
if rng.random() > spawn_prob:
|
||||
continue
|
||||
|
||||
# Cooler, higher ground skews to birch
|
||||
if column_height > sea_level + 35:
|
||||
tree_type = "birch" if rng.random() < 0.7 else "oak"
|
||||
elif column_height > sea_level + 15:
|
||||
tree_type = "oak" if rng.random() < 0.7 else "birch"
|
||||
else:
|
||||
tree_type = "oak"
|
||||
|
||||
tree = worldGen.generateTree(
|
||||
candidate_x,
|
||||
column_height + 1,
|
||||
candidate_z,
|
||||
tree_type=tree_type,
|
||||
variation=None,
|
||||
rng=rng,
|
||||
)
|
||||
if not tree:
|
||||
continue
|
||||
|
||||
for bx, by, bz, block_id in tree:
|
||||
# Only apply blocks that fall inside this chunk
|
||||
if chunk_x * 16 <= bx <= chunk_x * 16 + 15 and chunk_z * 16 <= bz <= chunk_z * 16 + 15:
|
||||
if 0 <= by < 256:
|
||||
tree_blocks[(bx, by, bz)] = block_id
|
||||
return tree_blocks
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# BIOME / TEMPERATURE FUNCTIONS (your original, with a small bug fix)
|
||||
# ---------------------------------------------------------------------------
|
||||
class biomeFuncs:
|
||||
@staticmethod
|
||||
def get_current_block_tmep(x, y, z):
|
||||
# TODO: You can later use height, biome, time, etc. to get the exact
|
||||
# temperature at this block. For now it's just a stub.
|
||||
#remember to account for things getting cooler/hotter as we dig.
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def get_current_biome_temp(biome, time, season):
|
||||
"""
|
||||
Compute the current temperature for a given biome at a given time/season.
|
||||
NOTE: I fixed a small bug:
|
||||
- You were looping "for biome in biome_base_temps" which overwrote
|
||||
the biome parameter and always ended with the last one.
|
||||
- Now we just look up the base temp directly from the biome argument.
|
||||
"""
|
||||
# Get base temperature for the biome (e.g. plains: 80)
|
||||
base_temp = biome_base_temps.get(biome, 70) # default 70 if biome unknown
|
||||
# Calculate weather adjustments based on biome and season
|
||||
standardWeatherAdjustment = 0
|
||||
weatherVariabilityFactor = 0
|
||||
if biome == "desert":
|
||||
if season == "winter":
|
||||
standardWeatherAdjustment = -30
|
||||
elif season == "fall":
|
||||
standardWeatherAdjustment = -10
|
||||
elif season == "summer":
|
||||
standardWeatherAdjustment = +10
|
||||
elif season == "spring":
|
||||
standardWeatherAdjustment = 0
|
||||
weatherVariabilityFactor = random.randint(-20, 20)
|
||||
elif biome == "plains":
|
||||
if season == "winter":
|
||||
standardWeatherAdjustment = -25
|
||||
elif season == "fall":
|
||||
standardWeatherAdjustment = -5
|
||||
elif season == "summer":
|
||||
standardWeatherAdjustment = +5
|
||||
elif season == "spring":
|
||||
standardWeatherAdjustment = 0
|
||||
weatherVariabilityFactor = random.randint(-15, 15)
|
||||
elif biome == "plains_river":
|
||||
if season == "winter":
|
||||
standardWeatherAdjustment = -20
|
||||
elif season == "fall":
|
||||
standardWeatherAdjustment = -3
|
||||
elif season == "summer":
|
||||
standardWeatherAdjustment = +3
|
||||
elif season == "spring":
|
||||
standardWeatherAdjustment = 0
|
||||
weatherVariabilityFactor = random.randint(-10, 10)
|
||||
elif biome == "rolling_hills":
|
||||
if season == "winter":
|
||||
standardWeatherAdjustment = -28
|
||||
elif season == "fall":
|
||||
standardWeatherAdjustment = -7
|
||||
elif season == "summer":
|
||||
standardWeatherAdjustment = +7
|
||||
elif season == "spring":
|
||||
standardWeatherAdjustment = 0
|
||||
weatherVariabilityFactor = random.randint(-18, 18)
|
||||
# -------------------------------------------------------------------
|
||||
# TIME-OF-DAY TEMPERATURE ADJUSTMENT (your original logic)
|
||||
# -------------------------------------------------------------------
|
||||
time_adjustment = 0
|
||||
# Convert time (0–24000 ticks) into a "Minecraft hour" in [0, 24).
|
||||
# 0 ticks = 6am, 6000 = 12pm, 12000 = 6pm, 18000 = 12am
|
||||
minecraft_hour = (time / 1000 + 6) % 24
|
||||
if 6 <= minecraft_hour < 14: # Morning to peak heat
|
||||
time_progress = (minecraft_hour - 6) / 8 # 0..1
|
||||
time_adjustment = time_progress * 15 # 0..+15
|
||||
elif 14 <= minecraft_hour < 20: # Afternoon to evening
|
||||
time_progress = (minecraft_hour - 14) / 6 # 0..1
|
||||
time_adjustment = 15 - (time_progress * 12) # +15..+3
|
||||
elif 20 <= minecraft_hour < 24: # Evening to midnight
|
||||
time_progress = (minecraft_hour - 20) / 4 # 0..1
|
||||
time_adjustment = 3 - (time_progress * 8) # +3..-5
|
||||
else: # Midnight to morning (0-6)
|
||||
time_progress = minecraft_hour / 6 # 0..1
|
||||
time_adjustment = -5 + (time_progress * 5) # -5..0
|
||||
# Apply biome-specific time modifiers
|
||||
if biome == "desert":
|
||||
time_adjustment *= 1.5 # Deserts have more extreme swings
|
||||
elif biome == "plains_river":
|
||||
time_adjustment *= 0.7 # Rivers moderate temperature changes
|
||||
# Final temperature
|
||||
temp = base_temp + standardWeatherAdjustment + weatherVariabilityFactor + time_adjustment
|
||||
return temp
|
||||
Reference in New Issue
Block a user