active-cubiomes/tests/test_search.py
2026-10-12 10:23:10 +00:00

577 lines
21 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""Tests for cubiomes.search module — basic and advanced conditions."""
import json
import subprocess
import sys
import pytest
from cubiomes import MCVersion, BiomeID, StructureType, Dimension
from cubiomes.search import (
# condition types
BiomeCondition, StructureCondition,
SpawnCondition, StrongholdCondition, ProximityCondition,
QuadStructureCondition, BiomeDensityCondition,
SlimeDensityCondition, AnyOfBiomes, CustomCondition,
# main classes
SearchCriteria, SeedResult, SeedSearch,
# helpers
_mc_name, _resolve_mc, _resolve_biome,
)
MC = MCVersion.MC_1_21
SEED = 123456789
# ─── Helpers ─────────────────────────────────────────────────────────────────
class TestHelpers:
def test_mc_name(self):
assert _mc_name(MCVersion.MC_1_21) == "1.21.11"
assert _mc_name(MCVersion.MC_1_18) == "1.18.2"
assert _mc_name(MCVersion.MC_B1_7) == "B1.7"
def test_resolve_mc(self):
assert _resolve_mc("1.21") == MCVersion.MC_1_21
def test_resolve_biome_by_name(self):
assert _resolve_biome("plains") == BiomeID.plains
def test_resolve_biome_by_int(self):
assert _resolve_biome("1") == 1
def test_resolve_biome_unknown(self):
import argparse
with pytest.raises(argparse.ArgumentTypeError):
_resolve_biome("__not_a_biome__")
# ─── SeedResult ───────────────────────────────────────────────────────────────
class TestSeedResult:
def test_as_dict(self):
r = SeedResult(seed=42, mc=MC,
biome_positions={"plains": (10, 20)},
structure_positions={"Village": (100, 200)},
spawn=(64, -48), spawn_biome=BiomeID.forest,
extra={"slime_chunk_count": 7})
d = r.as_dict()
assert d["seed"] == 42
assert d["mc_name"] == "1.21.11"
assert d["extra"]["slime_chunk_count"] == 7
def test_str_contains_quad(self):
r = SeedResult(seed=42, mc=MC,
quad={"name": "Swamp_Hut", "center": (100, 200),
"positions": [(90,190),(110,190),(90,210),(110,210)],
"max_r": 15.0})
s = str(r)
assert "quad" in s
assert "Swamp_Hut" in s
def test_str_contains_extra(self):
r = SeedResult(seed=42, mc=MC, extra={"density_badlands": 0.42})
assert "0.42" in str(r)
# ─── Basic conditions ─────────────────────────────────────────────────────────
class TestBasicConditions:
def test_biome_match(self):
criteria = SearchCriteria(
mc=MC,
biomes=[BiomeCondition(BiomeID.river, radius=500)],
)
result = SeedSearch(criteria).check_seed(SEED)
assert result is not None
assert "river" in result.biome_positions
def test_structure_match(self):
criteria = SearchCriteria(
mc=MC,
structures=[StructureCondition(StructureType.Village, radius=2000)],
)
result = SeedSearch(criteria).check_seed(SEED)
assert result is not None
assert "Village" in result.structure_positions
def test_slime_chunk_pass(self):
criteria = SearchCriteria(mc=MC, slime_chunk=(0, 1))
assert SeedSearch(criteria).check_seed(SEED) is not None
def test_slime_chunk_fail(self):
criteria = SearchCriteria(mc=MC, slime_chunk=(0, 0))
assert SeedSearch(criteria).check_seed(SEED) is None
def test_legacy_spawn_biome(self):
# Old-style spawn_biome field still works
sb = SeedSearch(SearchCriteria(mc=MC)).check_seed(SEED, show_spawn=True)
assert sb is not None
biome_at_spawn = sb.spawn_biome
criteria = SearchCriteria(mc=MC, spawn_biome=biome_at_spawn)
assert SeedSearch(criteria).check_seed(SEED) is not None
# ─── Advanced conditions ──────────────────────────────────────────────────────
class TestSpawnCondition:
def test_spawn_condition_biome(self):
# First, find the actual spawn biome
from cubiomes import Generator, Dimension
g = Generator(MC)
g.apply_seed(Dimension.DIM_OVERWORLD, SEED)
sp = g.estimate_spawn()
sb = g.get_biome_at(sp[0] >> 2, 0, sp[1] >> 2, scale=4)
criteria = SearchCriteria(
mc=MC,
conditions=[SpawnCondition(biome_id=sb)],
)
result = SeedSearch(criteria).check_seed(SEED)
assert result is not None
assert result.spawn_biome == sb
def test_spawn_condition_max_distance_pass(self):
criteria = SearchCriteria(
mc=MC,
conditions=[SpawnCondition(max_distance=10000)],
)
assert SeedSearch(criteria).check_seed(SEED) is not None
def test_spawn_condition_max_distance_fail(self):
criteria = SearchCriteria(
mc=MC,
conditions=[SpawnCondition(max_distance=1)],
)
# Spawn is at (64, -48) — definitely further than 1 block
assert SeedSearch(criteria).check_seed(SEED) is None
def test_spawn_condition_stores_spawn(self):
criteria = SearchCriteria(
mc=MC,
conditions=[SpawnCondition(max_distance=10000)],
)
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
assert r.spawn is not None
assert isinstance(r.spawn[0], int)
class TestStrongholdCondition:
def test_stronghold_within_large_radius(self):
criteria = SearchCriteria(
mc=MC,
conditions=[StrongholdCondition(count=1, max_distance=5000)],
)
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
assert len(r.strongholds) == 1
def test_stronghold_too_far(self):
criteria = SearchCriteria(
mc=MC,
conditions=[StrongholdCondition(count=1, max_distance=10)],
)
# First stronghold is at ~1947 blocks
assert SeedSearch(criteria).check_seed(SEED) is None
def test_stronghold_multiple_count(self):
criteria = SearchCriteria(
mc=MC,
conditions=[StrongholdCondition(count=3, max_distance=5000)],
)
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
assert len(r.strongholds) == 3
def test_strongholds_in_result(self):
criteria = SearchCriteria(
mc=MC,
conditions=[StrongholdCondition(count=2, max_distance=5000)],
)
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
for sh in r.strongholds:
assert isinstance(sh[0], int) and isinstance(sh[1], int)
class TestProximityCondition:
def test_proximity_loose(self):
# Village and Monument within 5000 blocks of each other should be easy
criteria = SearchCriteria(
mc=MC,
conditions=[ProximityCondition(
struct_a=StructureType.Village,
struct_b=StructureType.Monument,
max_dist=5000, search_radius=4000,
)],
)
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
assert "Village" in r.structure_positions
assert "Monument" in r.structure_positions
def test_proximity_impossible(self):
# Village within 1 block of Monument — impossible
criteria = SearchCriteria(
mc=MC,
conditions=[ProximityCondition(
struct_a=StructureType.Village,
struct_b=StructureType.Monument,
max_dist=1, search_radius=4000,
)],
)
assert SeedSearch(criteria).check_seed(SEED) is None
def test_proximity_distance_recorded(self):
criteria = SearchCriteria(
mc=MC,
conditions=[ProximityCondition(
StructureType.Village, StructureType.Monument,
max_dist=5000, search_radius=4000,
)],
)
r = SeedSearch(criteria).check_seed(SEED)
if r is not None:
import math
va = r.structure_positions.get("Village")
mo = r.structure_positions.get("Monument")
if va and mo:
d = math.sqrt((va[0]-mo[0])**2 + (va[1]-mo[1])**2)
assert d <= 5000
class TestQuadStructureCondition:
def test_quad_no_result_for_tight_limit(self):
# Strict quad (max_dist=1) should fail for this seed
criteria = SearchCriteria(
mc=MC,
conditions=[QuadStructureCondition(
StructureType.Swamp_Hut, max_dist=1, max_regions=2,
)],
)
assert SeedSearch(criteria).check_seed(SEED) is None
def test_quad_result_structure(self):
# Loose quad (max_dist=9999) should find something in a range search
criteria = SearchCriteria(
mc=MC,
conditions=[QuadStructureCondition(
StructureType.Village, max_dist=9999, max_regions=2,
)],
)
results = list(SeedSearch(criteria).run(seed_range=(0, 200), count=2))
for r in results:
assert r.quad is not None
assert r.quad["name"] == "Village"
assert len(r.quad["positions"]) == 4
assert "center" in r.quad
assert "max_r" in r.quad
def test_quad_positions_in_structure_positions(self):
criteria = SearchCriteria(
mc=MC,
conditions=[QuadStructureCondition(
StructureType.Village, max_dist=9999, max_regions=2,
)],
)
results = list(SeedSearch(criteria).run(seed_range=(0, 50), count=1))
if results:
r = results[0]
assert any("Village_quad_" in k for k in r.structure_positions)
class TestBiomeDensityCondition:
def test_density_always_passes_with_zero(self):
criteria = SearchCriteria(
mc=MC,
conditions=[BiomeDensityCondition(
biome_id=BiomeID.ocean, min_fraction=0.0,
x=-128, z=-128, sx=256, sz=256,
)],
)
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
def test_density_fails_impossible(self):
# 100% cherry grove in 512×512 — impossible
criteria = SearchCriteria(
mc=MC,
conditions=[BiomeDensityCondition(
biome_id=BiomeID.cherry_grove, min_fraction=1.0,
x=-128, z=-128, sx=64, sz=64,
)],
)
assert SeedSearch(criteria).check_seed(SEED) is None
def test_density_stored_in_extra(self):
criteria = SearchCriteria(
mc=MC,
conditions=[BiomeDensityCondition(
biome_id=BiomeID.plains, min_fraction=0.0,
x=-64, z=-64, sx=128, sz=128,
)],
)
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
assert any("density_plains" in k for k in r.extra)
class TestSlimeDensityCondition:
def test_slime_density_zero_always_passes(self):
criteria = SearchCriteria(
mc=MC,
conditions=[SlimeDensityCondition(min_count=0, cx=-4, cz=-4, cw=9, ch=9)],
)
assert SeedSearch(criteria).check_seed(SEED) is not None
def test_slime_density_too_high_fails(self):
# Require all 81 slime chunks — impossible
criteria = SearchCriteria(
mc=MC,
conditions=[SlimeDensityCondition(min_count=81, cx=-4, cz=-4, cw=9, ch=9)],
)
assert SeedSearch(criteria).check_seed(SEED) is None
def test_slime_density_count_in_extra(self):
criteria = SearchCriteria(
mc=MC,
conditions=[SlimeDensityCondition(min_count=0, cx=-4, cz=-4, cw=9, ch=9)],
)
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
assert "slime_chunk_count" in r.extra
assert isinstance(r.extra["slime_chunk_count"], int)
class TestAnyOfBiomes:
def test_any_biomes_one_match(self):
# river is at (0,0) for this seed
criteria = SearchCriteria(
mc=MC,
conditions=[AnyOfBiomes(
[BiomeID.river, BiomeID.mushroom_fields], radius=500,
)],
)
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
assert any("any_of(" in k for k in r.biome_positions)
def test_any_biomes_none_match(self):
# Impossible list, tiny radius
criteria = SearchCriteria(
mc=MC,
conditions=[AnyOfBiomes([BiomeID.mushroom_fields], radius=1)],
)
assert SeedSearch(criteria).check_seed(SEED) is None
def test_any_biomes_or_semantics(self):
# Both options are valid — should return on first found
criteria = SearchCriteria(
mc=MC,
conditions=[AnyOfBiomes([BiomeID.river, BiomeID.ocean], radius=2000)],
)
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
class TestCustomCondition:
def test_custom_pass(self):
def always_true(seed, mc):
return True
criteria = SearchCriteria(mc=MC, conditions=[CustomCondition(always_true)])
assert SeedSearch(criteria).check_seed(SEED) is not None
def test_custom_fail(self):
def always_false(seed, mc):
return False
criteria = SearchCriteria(mc=MC, conditions=[CustomCondition(always_false)])
assert SeedSearch(criteria).check_seed(SEED) is None
def test_custom_returns_dict(self):
def returns_data(seed, mc):
return {"custom_key": 42, "seed_doubled": seed * 2}
criteria = SearchCriteria(mc=MC, conditions=[CustomCondition(returns_data)])
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
assert r.extra["custom_key"] == 42
assert r.extra["seed_doubled"] == SEED * 2
def test_custom_with_generator(self):
from cubiomes import Generator, Dimension
def check_village_close(seed, mc):
from cubiomes import get_structure_pos, is_viable_structure_pos, StructureType
g = Generator(mc)
g.apply_seed(Dimension.DIM_OVERWORLD, seed)
for rx in range(-2, 3):
for rz in range(-2, 3):
pos = get_structure_pos(StructureType.Village, mc, seed, rx, rz)
if pos and is_viable_structure_pos(StructureType.Village, g, *pos):
if pos[0]**2 + pos[1]**2 <= 500**2:
return {"closest_village": pos}
return False
criteria = SearchCriteria(mc=MC, conditions=[CustomCondition(check_village_close)])
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
assert "closest_village" in r.extra
def test_custom_combined_with_native(self):
def extra_check(seed, mc):
return seed % 2 == 1
criteria = SearchCriteria(
mc=MC,
structures=[StructureCondition(StructureType.Village, radius=2000)],
conditions=[CustomCondition(extra_check)],
)
# SEED=123456789 is odd, so custom passes; Village exists so native passes
r = SeedSearch(criteria).check_seed(SEED)
assert r is not None
# ─── SearchCriteria combined ──────────────────────────────────────────────────
class TestCombinedCriteria:
def test_all_conditions_must_pass(self):
# Village nearby AND impossible density — should fail
criteria = SearchCriteria(
mc=MC,
structures=[StructureCondition(StructureType.Village, radius=2000)],
conditions=[BiomeDensityCondition(
BiomeID.mushroom_fields, min_fraction=1.0,
x=-64, z=-64, sx=128, sz=128,
)],
)
assert SeedSearch(criteria).check_seed(SEED) is None
def test_empty_criteria_always_passes(self):
criteria = SearchCriteria(mc=MC)
assert SeedSearch(criteria).check_seed(SEED) is not None
def test_run_respects_count(self):
criteria = SearchCriteria(mc=MC)
results = list(SeedSearch(criteria).run(seed_range=(0, 1000), count=3))
assert len(results) == 3
# ─── CLI ─────────────────────────────────────────────────────────────────────
class TestCLI:
def _run(self, *args):
return subprocess.run(
[sys.executable, "-m", "cubiomes.search"] + list(args),
capture_output=True, text=True,
)
def test_help(self):
r = self._run("--help")
assert r.returncode == 0
assert "quad" in r.stdout.lower()
assert "proximity" in r.stdout.lower()
def test_info_mode(self):
r = self._run("--seed", str(SEED), "--info")
assert r.returncode == 0
assert str(SEED) in r.stdout
assert "strongholds" in r.stdout.lower()
def test_single_seed_match(self):
r = self._run("--seed", str(SEED),
"--structure", "Village", "--struct-radius", "500")
assert r.returncode == 0
assert "Village" in r.stdout
def test_single_seed_no_match(self):
r = self._run("--seed", str(SEED),
"--structure", "Village", "--struct-radius", "1")
assert r.returncode == 1
def test_range_json(self):
r = self._run("--seeds", "0:200",
"--structure", "Village", "--struct-radius", "300",
"--count", "2", "--format", "json", "--no-progress")
assert r.returncode == 0
data = json.loads(r.stdout)
assert isinstance(data, list)
def test_range_csv(self):
r = self._run("--seeds", "0:200",
"--structure", "Village", "--struct-radius", "300",
"--count", "2", "--format", "csv", "--no-progress")
assert r.returncode == 0
lines = r.stdout.strip().split("\n")
assert lines[0].startswith("seed,mc,")
def test_any_biome_flag(self):
r = self._run("--seed", str(SEED),
"--any-biome", "river", "ocean", "--biome-radius", "500")
assert r.returncode == 0
def test_spawn_biome_flag(self):
# Get spawn biome first
from cubiomes import Generator, Dimension
g = Generator(MC)
g.apply_seed(Dimension.DIM_OVERWORLD, SEED)
sp = g.estimate_spawn()
sb = g.get_biome_at(sp[0] >> 2, 0, sp[1] >> 2, scale=4)
bname = BiomeID(sb).name
r = self._run("--seed", str(SEED), "--spawn-biome", bname)
assert r.returncode == 0
def test_spawn_max_dist_pass(self):
r = self._run("--seed", str(SEED), "--spawn-max-dist", "10000")
assert r.returncode == 0
def test_spawn_max_dist_fail(self):
r = self._run("--seed", str(SEED), "--spawn-max-dist", "1")
assert r.returncode == 1
def test_stronghold_radius_flag(self):
r = self._run("--seed", str(SEED),
"--stronghold-radius", "5000", "--stronghold-count", "1")
assert r.returncode == 0
def test_proximity_flag(self):
r = self._run("--seed", str(SEED),
"--proximity", "Village", "Monument", "5000",
"--no-progress")
assert r.returncode == 0
assert "Village" in r.stdout
assert "Monument" in r.stdout
def test_proximity_fail(self):
r = self._run("--seed", str(SEED),
"--proximity", "Village", "Monument", "1",
"--no-progress")
assert r.returncode == 1
def test_biome_density_flag(self):
r = self._run("--seed", str(SEED),
"--biome-density", "river", "0.0",
"--no-progress")
assert r.returncode == 0
def test_min_slime_chunks_flag(self):
r = self._run("--seed", str(SEED), "--min-slime-chunks", "1")
assert r.returncode == 0
def test_min_slime_chunks_impossible(self):
r = self._run("--seed", str(SEED), "--min-slime-chunks", "81")
assert r.returncode == 1
def test_quad_flag_range(self):
# Loose quad should find results quickly
r = self._run("--seeds", "0:50",
"--quad", "Village", "--quad-dist", "9999",
"--quad-max-regions", "2",
"--count", "1", "--no-progress")
assert r.returncode == 0
def test_unknown_biome(self):
r = self._run("--biome", "__no_such_biome__", "--seeds", "0:10")
assert r.returncode != 0