commit 843f1ce8f36adf2be03b505d941045ac3d19ed28 Author: Arigadam Date: Tue Oct 13 09:27:20 2026 +0000 Add celseed: Minecraft seed finder with CEL filter expressions Single-file C CLI program that searches Minecraft seeds using cubiomes for biome/structure generation and a built-in CEL-subset expression evaluator for filtering. Supports all MC versions from Beta 1.7 to 26.3. Co-Authored-By: Claude Sonnet 4.6 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b4ef353 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +celseed +*.o diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..aafaabf --- /dev/null +++ b/.gitmodules @@ -0,0 +1,6 @@ +[submodule "cel-c"] + path = cel-c + url = https://github.com/cel-expr/cel-c.git +[submodule "cubiomes"] + path = cubiomes + url = https://github.com/xpple/cubiomes.git diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..8c112b6 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 Arigadam + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..3e97669 --- /dev/null +++ b/Makefile @@ -0,0 +1,37 @@ +CC = gcc +CFLAGS = -O2 -Wall -Wextra -std=c11 + +CUBIOMES_SRCS = \ + cubiomes/biomenoise.c \ + cubiomes/biomes.c \ + cubiomes/finders.c \ + cubiomes/generator.c \ + cubiomes/layers.c \ + cubiomes/noise.c \ + cubiomes/quadbase.c \ + cubiomes/terrainnoise.c \ + cubiomes/util.c \ + cubiomes/xradv.c \ + cubiomes/features/abandoned_camp.c \ + cubiomes/features/end_city.c \ + cubiomes/features/fortress.c \ + cubiomes/features/ore.c \ + cubiomes/features/stronghold.c + +CUBIOMES_OBJS = $(CUBIOMES_SRCS:.c=.o) + +.PHONY: all clean + +all: celseed + +celseed: celseed.o $(CUBIOMES_OBJS) + $(CC) -o $@ $^ -lm + +celseed.o: celseed.c + $(CC) $(CFLAGS) -Wno-format-truncation -Wno-stringop-truncation -c -o $@ $< + +$(CUBIOMES_OBJS): %.o: %.c + $(CC) $(CFLAGS) -Icubiomes -w -c -o $@ $< + +clean: + rm -f celseed celseed.o $(CUBIOMES_OBJS) diff --git a/README.md b/README.md new file mode 100644 index 0000000..64dbe8c --- /dev/null +++ b/README.md @@ -0,0 +1,254 @@ +# celseed + +**English** | [Русский](#russian) + +Minecraft seed finder for all versions. Give it a filter expression and it +prints seeds that match. + +--- + +## Build + +Requires: `gcc`, `make`, `libm`. + +``` +git clone --recurse-submodules +make +``` + +The binary `celseed` is created in the project root. + +--- + +## Usage + +``` +celseed [OPTIONS] +``` + +| Option | Default | Description | +|--------|---------|-------------| +| `--mc VERSION` | newest | Minecraft version, e.g. `1.21`, `1.18`, `1.7`, `b1.8` | +| `--filter EXPR` | *(none)* | CEL filter expression | +| `--count N` | 10 | Stop after N matches | +| `--from SEED` | 0 | Starting seed (signed int64) | +| `--to SEED` | *(unlimited)* | Ending seed (exclusive) | +| `--step N` | 1 | Seed increment | +| `--random` | off | Use random seeds instead of sequential | +| `--dim overworld\|nether\|end` | overworld | Dimension | +| `--large` | off | Enable large biomes | +| `--quiet` | off | Print only seed values | +| `--verbose` | off | Print index alongside value | +| `--list-versions` | — | List all supported versions | + +--- + +## Filter expressions + +The `--filter` expression is a subset of +[CEL (Common Expression Language)](https://cel.dev). + +### Variables + +| Name | Type | Description | +|------|------|-------------| +| `seed` | int | Current seed value | + +### Functions + +| Function | Returns | Description | +|----------|---------|-------------| +| `biome(x, z)` | string | Biome name at block coordinates | +| `biome_id(x, z)` | int | Numeric biome ID at block coordinates | +| `has_biome(name, x, z, r)` | bool | Biome exists within radius `r` around `(x, z)` | +| `structure(type, rx, rz)` | bool | Viable structure at region `(rx, rz)` | +| `struct_x(type, rx, rz)` | int | Structure block X coordinate | +| `struct_z(type, rx, rz)` | int | Structure block Z coordinate | +| `spawn_x()` | int | World spawn X coordinate | +| `spawn_z()` | int | World spawn Z coordinate | + +### Operators + +`&&` `||` `!` `==` `!=` `<` `<=` `>` `>=` `+` `-` `*` `/` `%` + +### Structure types + +`village` `mansion` `monument` `outpost` `desert_pyramid` `jungle_temple` +`swamp_hut` `igloo` `ocean_ruin` `shipwreck` `ruined_portal` `ancient_city` +`fortress` `bastion` `end_city` `stronghold` `trail_ruins` `trial_chambers` + +--- + +## Examples + +Find seeds where spawn is inside a jungle: +``` +celseed --mc 1.21 --filter 'biome(0,0) == "jungle"' +``` + +Find seeds with a mushroom island within 500 blocks of origin: +``` +celseed --mc 1.18 --filter 'has_biome("mushroom_fields", 0, 0, 500)' --count 5 +``` + +Find seeds with a village and a mansion in region (0,0) and (1,0): +``` +celseed --mc 1.16 --filter 'structure("village",0,0) && structure("mansion",1,0)' +``` + +Search random seeds for a jungle with a temple nearby: +``` +celseed --random --filter 'biome(0,0) == "jungle" && structure("jungle_temple",0,0)' +``` + +Check seeds where spawn is near the origin: +``` +celseed --filter 'spawn_x() > -200 && spawn_x() < 200 && spawn_z() > -200 && spawn_z() < 200' +``` + +Scan a specific seed range: +``` +celseed --from -500000 --to 500000 --filter 'seed % 1000 == 0' --count 20 +``` + +--- + +## Notes + +- Biome and structure queries use cubiomes for fast generation without + launching Minecraft. +- `x`, `z` in `biome()` and `has_biome()` are block coordinates. +- `rx`, `rz` in `structure()` are region indices (each region is typically + 32 chunks, i.e. 512 blocks, depending on structure type). +- The filter syntax follows CEL principles; the evaluator is implemented + in C as part of this tool (the `cel-c` submodule is included for reference). + +--- + +## License + +MIT – see [LICENSE](LICENSE). + +--- + + + +# celseed (Русский) + +Поиск сидов Minecraft для всех версий. Задайте фильтр — программа напечатает подходящие сиды. + +--- + +## Сборка + +Требуется: `gcc`, `make`, `libm`. + +``` +git clone --recurse-submodules +make +``` + +В корне проекта появится исполняемый файл `celseed`. + +--- + +## Использование + +``` +celseed [ОПЦИИ] +``` + +| Опция | По умолчанию | Описание | +|-------|--------------|----------| +| `--mc VERSION` | newest | Версия Minecraft, например `1.21`, `1.18`, `1.7`, `b1.8` | +| `--filter EXPR` | *(нет)* | Фильтр-выражение в стиле CEL | +| `--count N` | 10 | Остановиться после N совпадений | +| `--from SEED` | 0 | Начальный сид (знаковый int64) | +| `--to SEED` | *(без ограничений)* | Конечный сид (не включая) | +| `--step N` | 1 | Шаг перебора сидов | +| `--random` | выкл | Случайные сиды вместо последовательных | +| `--dim overworld\|nether\|end` | overworld | Измерение | +| `--large` | выкл | Большие биомы | +| `--quiet` | выкл | Печатать только значения сидов | +| `--verbose` | выкл | Печатать индекс рядом со значением | +| `--list-versions` | — | Список поддерживаемых версий | + +--- + +## Фильтр-выражения + +Выражение `--filter` — это подмножество +[CEL (Common Expression Language)](https://cel.dev). + +### Переменные + +| Имя | Тип | Описание | +|-----|-----|----------| +| `seed` | int | Текущее значение сида | + +### Функции + +| Функция | Возвращает | Описание | +|---------|-----------|----------| +| `biome(x, z)` | string | Название биома в блочных координатах | +| `biome_id(x, z)` | int | Числовой ID биома в блочных координатах | +| `has_biome(name, x, z, r)` | bool | Биом присутствует в радиусе `r` блоков от `(x, z)` | +| `structure(type, rx, rz)` | bool | Есть ли генерируемая структура в регионе `(rx, rz)` | +| `struct_x(type, rx, rz)` | int | Координата X структуры | +| `struct_z(type, rx, rz)` | int | Координата Z структуры | +| `spawn_x()` | int | Координата X точки спауна | +| `spawn_z()` | int | Координата Z точки спауна | + +### Операторы + +`&&` `||` `!` `==` `!=` `<` `<=` `>` `>=` `+` `-` `*` `/` `%` + +### Типы структур + +`village` `mansion` `monument` `outpost` `desert_pyramid` `jungle_temple` +`swamp_hut` `igloo` `ocean_ruin` `shipwreck` `ruined_portal` `ancient_city` +`fortress` `bastion` `end_city` `stronghold` `trail_ruins` `trial_chambers` + +--- + +## Примеры + +Сид, где спаун находится в джунглях: +``` +celseed --mc 1.21 --filter 'biome(0,0) == "jungle"' +``` + +Сид с грибным островом в радиусе 500 блоков от начала координат: +``` +celseed --mc 1.18 --filter 'has_biome("mushroom_fields", 0, 0, 500)' --count 5 +``` + +Сид с деревней и особняком рядом: +``` +celseed --mc 1.16 --filter 'structure("village",0,0) && structure("mansion",1,0)' +``` + +Случайные сиды с джунглями и храмом: +``` +celseed --random --filter 'biome(0,0) == "jungle" && structure("jungle_temple",0,0)' +``` + +Спаун близко к центру мира: +``` +celseed --filter 'spawn_x() > -200 && spawn_x() < 200 && spawn_z() > -200 && spawn_z() < 200' +``` + +--- + +## Примечания + +- Биомы и структуры определяются через библиотеку cubiomes без запуска Minecraft. +- `x`, `z` в `biome()` и `has_biome()` — блочные координаты. +- `rx`, `rz` в `structure()` — индексы регионов (обычно 32 чанка = 512 блоков). +- Синтаксис фильтра следует принципам CEL; вычислитель реализован на C. + +--- + +## Лицензия + +MIT — см. [LICENSE](LICENSE). diff --git a/cel-c b/cel-c new file mode 160000 index 0000000..d279040 --- /dev/null +++ b/cel-c @@ -0,0 +1 @@ +Subproject commit d2790407db22c857a24f659e10a2906d23bf0e6d diff --git a/celseed.c b/celseed.c new file mode 100644 index 0000000..0b1049d --- /dev/null +++ b/celseed.c @@ -0,0 +1,964 @@ +/* + * celseed - Minecraft seed finder using cubiomes + CEL filter expressions + * + * Filter syntax (subset of Common Expression Language): + * Literals: 42, 3.14, "text", true, false + * Variable: seed + * Operators: && || ! == != < <= > >= + - * / % + * Functions: biome(x,z) biome_id(x,z) has_biome(name,x,z,r) + * structure(type,rx,rz) struct_x(type,rx,rz) struct_z(type,rx,rz) + * spawn_x() spawn_z() + * + * MIT License – see LICENSE + */ + +#define _POSIX_C_SOURCE 200809L +#include +#include +#include +#include +#include +#include +#include +#include + +#include "cubiomes/generator.h" +#include "cubiomes/finders.h" +#include "cubiomes/biomes.h" +#include "cubiomes/util.h" + +/* ============================================================ + * Value type + * ========================================================== */ + +typedef enum { VT_NULL, VT_INT, VT_FLOAT, VT_STR, VT_BOOL, VT_ERR } VType; + +typedef struct { + VType type; + int64_t i; + double d; + bool b; + const char *s; /* static string or points into sbuf */ + char sbuf[64]; +} Val; + +static Val vint(int64_t v) { Val r; memset(&r,0,sizeof(r)); r.type=VT_INT; r.i=v; return r; } +static Val vfloat(double v) { Val r; memset(&r,0,sizeof(r)); r.type=VT_FLOAT; r.d=v; return r; } +static Val vbool(bool v) { Val r; memset(&r,0,sizeof(r)); r.type=VT_BOOL; r.b=v; return r; } +static Val vstr(const char *s) { Val r; memset(&r,0,sizeof(r)); r.type=VT_STR; r.s=s; return r; } +static Val verr(const char *m) { Val r; memset(&r,0,sizeof(r)); r.type=VT_ERR; r.s=m; return r; } + +static bool vtrue(Val v) { + switch (v.type) { + case VT_BOOL: return v.b; + case VT_INT: return v.i != 0; + case VT_FLOAT: return v.d != 0.0; + case VT_STR: return v.s && v.s[0]; + default: return false; + } +} + +static int vcmp(Val a, Val b) { + if (a.type == VT_INT && b.type == VT_INT) + return (a.i > b.i) - (a.i < b.i); + if ((a.type == VT_INT || a.type == VT_FLOAT) && + (b.type == VT_INT || b.type == VT_FLOAT)) { + double da = (a.type == VT_INT) ? (double)a.i : a.d; + double db = (b.type == VT_INT) ? (double)b.i : b.d; + return (da > db) - (da < db); + } + if (a.type == VT_STR && b.type == VT_STR) + return strcmp(a.s, b.s); + if (a.type == VT_BOOL && b.type == VT_BOOL) + return (int)a.b - (int)b.b; + return -2; +} + +static bool veq(Val a, Val b) { + if (a.type == VT_STR && b.type == VT_STR) + return strcmp(a.s, b.s) == 0; + return vcmp(a, b) == 0; +} + +/* ============================================================ + * Lexer + * ========================================================== */ + +typedef enum { + TK_EOF, TK_INT, TK_FLOAT, TK_STR, TK_IDENT, + TK_PLUS, TK_MINUS, TK_STAR, TK_SLASH, TK_PCT, + TK_EQ, TK_NEQ, TK_LT, TK_LE, TK_GT, TK_GE, + TK_AND, TK_OR, TK_BANG, + TK_LP, TK_RP, TK_COMMA, + TK_ERR +} TKind; + +#define SMAX 256 + +typedef struct { + TKind k; + int64_t ival; + double dval; + char sval[SMAX]; +} Tok; + +typedef struct { + const char *src; + int pos; + bool peeked; + Tok peek; + char err[SMAX]; +} Lex; + +static void lex_init(Lex *l, const char *src) { + l->src = src; + l->pos = 0; + l->peeked = false; + l->err[0] = '\0'; +} + +static Tok lex_read(Lex *l) { + Tok t; t.sval[0] = '\0'; + const char *s = l->src; + while (s[l->pos] == ' ' || s[l->pos] == '\t') l->pos++; + char c = s[l->pos]; + if (!c) { t.k = TK_EOF; return t; } + + if (c == '"') { + l->pos++; + int i = 0; + while (s[l->pos] && s[l->pos] != '"' && i < SMAX-1) + t.sval[i++] = s[l->pos++]; + t.sval[i] = '\0'; + if (s[l->pos] == '"') l->pos++; + t.k = TK_STR; + return t; + } + + if (c >= '0' && c <= '9') { + char *end; + t.ival = strtoll(s + l->pos, &end, 10); + if (*end == '.' || *end == 'e' || *end == 'E') { + t.dval = strtod(s + l->pos, &end); + t.k = TK_FLOAT; + } else { + t.k = TK_INT; + } + l->pos = (int)(end - s); + return t; + } + + if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_') { + int i = 0; + while ((s[l->pos] >= 'a' && s[l->pos] <= 'z') || + (s[l->pos] >= 'A' && s[l->pos] <= 'Z') || + (s[l->pos] >= '0' && s[l->pos] <= '9') || + s[l->pos] == '_') + t.sval[i++] = s[l->pos++]; + t.sval[i] = '\0'; + t.k = TK_IDENT; + return t; + } + + l->pos++; + switch (c) { + case '+': t.k = TK_PLUS; break; + case '-': t.k = TK_MINUS; break; + case '*': t.k = TK_STAR; break; + case '/': t.k = TK_SLASH; break; + case '%': t.k = TK_PCT; break; + case '(': t.k = TK_LP; break; + case ')': t.k = TK_RP; break; + case ',': t.k = TK_COMMA; break; + case '!': + if (s[l->pos]=='=') { l->pos++; t.k=TK_NEQ; } + else t.k = TK_BANG; + break; + case '<': + if (s[l->pos]=='=') { l->pos++; t.k=TK_LE; } + else t.k = TK_LT; + break; + case '>': + if (s[l->pos]=='=') { l->pos++; t.k=TK_GE; } + else t.k = TK_GT; + break; + case '=': + if (s[l->pos]=='=') { l->pos++; t.k=TK_EQ; } + else { snprintf(l->err,SMAX,"use '==' not '='"); t.k=TK_ERR; } + break; + case '&': + if (s[l->pos]=='&') { l->pos++; t.k=TK_AND; } + else { snprintf(l->err,SMAX,"use '&&' not '&'"); t.k=TK_ERR; } + break; + case '|': + if (s[l->pos]=='|') { l->pos++; t.k=TK_OR; } + else { snprintf(l->err,SMAX,"use '||' not '|'"); t.k=TK_ERR; } + break; + default: + snprintf(l->err, SMAX, "unexpected char '%c'", c); + t.k = TK_ERR; + break; + } + return t; +} + +static Tok lpeek(Lex *l) { + if (!l->peeked) { l->peek = lex_read(l); l->peeked = true; } + return l->peek; +} + +static Tok lconsume(Lex *l) { + Tok t = lpeek(l); + l->peeked = false; + return t; +} + +/* ============================================================ + * AST + * ========================================================== */ + +typedef enum { + ND_INT, ND_FLOAT, ND_STR, ND_BOOL, ND_VAR, ND_CALL, + ND_NEG, ND_NOT, + ND_MUL, ND_DIV, ND_MOD, + ND_ADD, ND_SUB, + ND_LT, ND_LE, ND_GT, ND_GE, + ND_EQ, ND_NEQ, + ND_AND, ND_OR, +} NKind; + +#define MAX_NODES 512 +#define MAX_ARGS 8 + +typedef struct Node Node; +struct Node { + NKind k; + int64_t ival; + double dval; + bool bval; + char name[SMAX]; + Node *lhs, *rhs; + Node *args[MAX_ARGS]; + int nargs; +}; + +typedef struct { + Node pool[MAX_NODES]; + int used; + char err[SMAX]; + Lex lex; +} Parser; + +static Node *palloc(Parser *p) { + if (p->used >= MAX_NODES) { + snprintf(p->err, SMAX, "expression too complex"); + return NULL; + } + Node *n = &p->pool[p->used++]; + memset(n, 0, sizeof(*n)); + return n; +} + +static Node *parse_expr(Parser *p); +static Node *parse_or(Parser *p); +static Node *parse_and(Parser *p); +static Node *parse_eq(Parser *p); +static Node *parse_cmp(Parser *p); +static Node *parse_add(Parser *p); +static Node *parse_mul(Parser *p); +static Node *parse_unary(Parser *p); +static Node *parse_primary(Parser *p); + +static Node *parse_expr(Parser *p) { return parse_or(p); } + +static Node *parse_or(Parser *p) { + Node *n = parse_and(p); if (!n) return NULL; + while (lpeek(&p->lex).k == TK_OR) { + lconsume(&p->lex); + Node *r = parse_and(p); if (!r) return NULL; + Node *op = palloc(p); if (!op) return NULL; + op->k = ND_OR; op->lhs = n; op->rhs = r; n = op; + } + return n; +} + +static Node *parse_and(Parser *p) { + Node *n = parse_eq(p); if (!n) return NULL; + while (lpeek(&p->lex).k == TK_AND) { + lconsume(&p->lex); + Node *r = parse_eq(p); if (!r) return NULL; + Node *op = palloc(p); if (!op) return NULL; + op->k = ND_AND; op->lhs = n; op->rhs = r; n = op; + } + return n; +} + +static Node *parse_eq(Parser *p) { + Node *n = parse_cmp(p); if (!n) return NULL; + for (;;) { + TKind k = lpeek(&p->lex).k; + if (k != TK_EQ && k != TK_NEQ) break; + lconsume(&p->lex); + Node *r = parse_cmp(p); if (!r) return NULL; + Node *op = palloc(p); if (!op) return NULL; + op->k = (k == TK_EQ) ? ND_EQ : ND_NEQ; + op->lhs = n; op->rhs = r; n = op; + } + return n; +} + +static Node *parse_cmp(Parser *p) { + Node *n = parse_add(p); if (!n) return NULL; + for (;;) { + TKind k = lpeek(&p->lex).k; + if (k!=TK_LT && k!=TK_LE && k!=TK_GT && k!=TK_GE) break; + lconsume(&p->lex); + Node *r = parse_add(p); if (!r) return NULL; + Node *op = palloc(p); if (!op) return NULL; + switch (k) { + case TK_LT: op->k=ND_LT; break; + case TK_LE: op->k=ND_LE; break; + case TK_GT: op->k=ND_GT; break; + default: op->k=ND_GE; break; + } + op->lhs = n; op->rhs = r; n = op; + } + return n; +} + +static Node *parse_add(Parser *p) { + Node *n = parse_mul(p); if (!n) return NULL; + for (;;) { + TKind k = lpeek(&p->lex).k; + if (k!=TK_PLUS && k!=TK_MINUS) break; + lconsume(&p->lex); + Node *r = parse_mul(p); if (!r) return NULL; + Node *op = palloc(p); if (!op) return NULL; + op->k = (k==TK_PLUS) ? ND_ADD : ND_SUB; + op->lhs = n; op->rhs = r; n = op; + } + return n; +} + +static Node *parse_mul(Parser *p) { + Node *n = parse_unary(p); if (!n) return NULL; + for (;;) { + TKind k = lpeek(&p->lex).k; + if (k!=TK_STAR && k!=TK_SLASH && k!=TK_PCT) break; + lconsume(&p->lex); + Node *r = parse_unary(p); if (!r) return NULL; + Node *op = palloc(p); if (!op) return NULL; + switch (k) { + case TK_STAR: op->k=ND_MUL; break; + case TK_SLASH: op->k=ND_DIV; break; + default: op->k=ND_MOD; break; + } + op->lhs = n; op->rhs = r; n = op; + } + return n; +} + +static Node *parse_unary(Parser *p) { + TKind k = lpeek(&p->lex).k; + if (k == TK_BANG || k == TK_MINUS) { + lconsume(&p->lex); + Node *op = palloc(p); if (!op) return NULL; + op->k = (k == TK_BANG) ? ND_NOT : ND_NEG; + op->lhs = parse_unary(p); + if (!op->lhs) return NULL; + return op; + } + return parse_primary(p); +} + +static Node *parse_primary(Parser *p) { + Tok t = lconsume(&p->lex); + Node *n; + switch (t.k) { + case TK_INT: + n = palloc(p); if (!n) return NULL; + n->k = ND_INT; n->ival = t.ival; + return n; + case TK_FLOAT: + n = palloc(p); if (!n) return NULL; + n->k = ND_FLOAT; n->dval = t.dval; + return n; + case TK_STR: + n = palloc(p); if (!n) return NULL; + n->k = ND_STR; + strncpy(n->name, t.sval, SMAX-1); + return n; + case TK_IDENT: + if (!strcmp(t.sval,"true")) { n=palloc(p); if(!n) return NULL; n->k=ND_BOOL; n->bval=true; return n; } + if (!strcmp(t.sval,"false")) { n=palloc(p); if(!n) return NULL; n->k=ND_BOOL; n->bval=false; return n; } + if (lpeek(&p->lex).k == TK_LP) { + lconsume(&p->lex); + n = palloc(p); if (!n) return NULL; + n->k = ND_CALL; + strncpy(n->name, t.sval, SMAX-1); + if (lpeek(&p->lex).k != TK_RP) { + for (;;) { + if (n->nargs >= MAX_ARGS) { + snprintf(p->err, SMAX, "too many args to %s()", n->name); + return NULL; + } + Node *a = parse_expr(p); if (!a) return NULL; + n->args[n->nargs++] = a; + if (lpeek(&p->lex).k != TK_COMMA) break; + lconsume(&p->lex); + } + } + if (lpeek(&p->lex).k != TK_RP) { + snprintf(p->err, SMAX, "expected ')' after args to %s()", n->name); + return NULL; + } + lconsume(&p->lex); + return n; + } + n = palloc(p); if (!n) return NULL; + n->k = ND_VAR; + strncpy(n->name, t.sval, SMAX-1); + return n; + case TK_LP: { + Node *inner = parse_expr(p); if (!inner) return NULL; + if (lpeek(&p->lex).k != TK_RP) { + snprintf(p->err, SMAX, "expected ')'"); + return NULL; + } + lconsume(&p->lex); + return inner; + } + default: + snprintf(p->err, SMAX, "unexpected token (kind=%d sval='%s')", t.k, t.sval); + return NULL; + } +} + +/* ============================================================ + * Evaluation context + * ========================================================== */ + +typedef struct { + uint64_t seed; + int mc; + int dim; + uint32_t flags; + Generator *gen; + bool gen_ready; + bool spawn_ready; + Pos spawn; +} Ctx; + +static void ensure_gen(Ctx *c) { + if (!c->gen_ready) { + applySeed(c->gen, c->dim, c->seed); + c->gen_ready = true; + } +} + +static Val eval_node(const Node *n, Ctx *ctx); + +/* ============================================================ + * Built-in functions + * ========================================================== */ + +/* strip optional "minecraft:" prefix for comparison */ +static const char *strip_ns(const char *s) { + if (s && strncmp(s, "minecraft:", 10) == 0) return s + 10; + return s; +} + +static bool biome_name_eq(const char *query, const char *result) { + if (!result) return false; + return strcasecmp(strip_ns(query), strip_ns(result)) == 0; +} + +static bool arg_int(const Node *n, Ctx *ctx, int idx, int *out) { + Val v = eval_node(n->args[idx], ctx); + if (v.type == VT_INT) { *out = (int)v.i; return true; } + if (v.type == VT_FLOAT) { *out = (int)v.d; return true; } + return false; +} + +static Val fn_biome(const Node *n, Ctx *ctx) { + if (n->nargs != 2) return verr("biome(x,z) takes 2 args"); + int x, z; + if (!arg_int(n,ctx,0,&x) || !arg_int(n,ctx,1,&z)) + return verr("biome() args must be numbers"); + ensure_gen(ctx); + int id = getBiomeAt(ctx->gen, 4, x>>2, 0, z>>2); + if (id < 0) return vstr("none"); + const char *nm = biome2str(ctx->mc, id); + return vstr(nm ? strip_ns(nm) : "unknown"); +} + +static Val fn_biome_id(const Node *n, Ctx *ctx) { + if (n->nargs != 2) return verr("biome_id(x,z) takes 2 args"); + int x, z; + if (!arg_int(n,ctx,0,&x) || !arg_int(n,ctx,1,&z)) + return verr("biome_id() args must be numbers"); + ensure_gen(ctx); + int id = getBiomeAt(ctx->gen, 4, x>>2, 0, z>>2); + return vint(id); +} + +static Val fn_has_biome(const Node *n, Ctx *ctx) { + if (n->nargs != 4) return verr("has_biome(name,x,z,r) takes 4 args"); + int cx, cz, cr; + if (!arg_int(n,ctx,1,&cx) || !arg_int(n,ctx,2,&cz) || !arg_int(n,ctx,3,&cr)) + return verr("has_biome() args 2,3,4 must be numbers"); + + Val bval = eval_node(n->args[0], ctx); + int target = -1; + + if (bval.type == VT_INT) { + target = (int)bval.i; + } else if (bval.type == VT_STR) { + /* search by name across all valid IDs */ + for (int id = 0; id < 256; id++) { + const char *nm = biome2str(ctx->mc, id); + if (biome_name_eq(bval.s, nm)) { target = id; break; } + } + /* fallback numeric lookup table for pre-1.13 */ + if (target < 0) { + static const struct { const char *name; int id; } tbl[] = { + {"ocean",0},{"plains",1},{"desert",2},{"mountains",3}, + {"forest",4},{"taiga",5},{"swamp",6},{"river",7}, + {"frozen_ocean",10},{"frozen_river",11},{"snowy_tundra",12}, + {"snowy_mountains",13},{"mushroom_fields",14},{"beach",16}, + {"desert_hills",17},{"wooded_hills",18},{"taiga_hills",19}, + {"jungle",21},{"jungle_hills",22},{"jungle_edge",23}, + {"deep_ocean",24},{"stone_shore",25},{"snowy_beach",26}, + {"birch_forest",27},{"birch_forest_hills",28},{"dark_forest",29}, + {"snowy_taiga",30},{"snowy_taiga_hills",31}, + {"giant_tree_taiga",32},{"giant_tree_taiga_hills",33}, + {"wooded_mountains",34},{"savanna",35},{"savanna_plateau",36}, + {"badlands",37},{"wooded_badlands_plateau",38}, + {"badlands_plateau",39},{"warm_ocean",44},{"lukewarm_ocean",45}, + {"cold_ocean",46},{"deep_warm_ocean",47}, + {"deep_lukewarm_ocean",48},{"deep_cold_ocean",49}, + {"deep_frozen_ocean",50}, + {NULL,0} + }; + for (int i = 0; tbl[i].name; i++) + if (strcasecmp(tbl[i].name, bval.s)==0) { target=tbl[i].id; break; } + } + if (target < 0) return verr("has_biome(): unknown biome name"); + } else { + return verr("has_biome() arg 1 must be string or int"); + } + + ensure_gen(ctx); + int r4 = (cr >> 2) + 1; + int cx4 = cx >> 2, cz4 = cz >> 2; + int step = (r4 / 32) + 1; + for (int z4 = cz4-r4; z4 <= cz4+r4; z4 += step) { + for (int x4 = cx4-r4; x4 <= cx4+r4; x4 += step) { + if (getBiomeAt(ctx->gen, 4, x4, 0, z4) == target) + return vbool(true); + } + } + return vbool(false); +} + +static int parse_stype(const char *s) { + static const struct { const char *n; int v; } map[] = { + {"desert_pyramid",Desert_Pyramid},{"jungle_temple",Jungle_Temple}, + {"swamp_hut",Swamp_Hut},{"igloo",Igloo},{"village",Village}, + {"ocean_ruin",Ocean_Ruin},{"shipwreck",Shipwreck}, + {"monument",Monument},{"mansion",Mansion},{"outpost",Outpost}, + {"ruined_portal",Ruined_Portal},{"ancient_city",Ancient_City}, + {"treasure",Treasure},{"fortress",Fortress},{"bastion",Bastion}, + {"end_city",End_City},{"stronghold",Stronghold}, + {"trail_ruins",Trail_Ruins},{"trial_chambers",Trial_Chambers}, + {NULL,0} + }; + for (int i = 0; map[i].n; i++) + if (strcasecmp(map[i].n, s)==0) return map[i].v; + return -1; +} + +static Val fn_structure(const Node *n, Ctx *ctx) { + if (n->nargs != 3) return verr("structure(type,rx,rz) takes 3 args"); + Val tv = eval_node(n->args[0], ctx); + if (tv.type != VT_STR) return verr("structure() arg 1 must be string"); + int stype = parse_stype(tv.s); + if (stype < 0) return verr("structure(): unknown structure type"); + int rx, rz; + if (!arg_int(n,ctx,1,&rx) || !arg_int(n,ctx,2,&rz)) + return verr("structure() args 2,3 must be numbers"); + StructureConfig sc; + if (!getStructureConfig(stype, ctx->mc, &sc)) return vbool(false); + Pos pos; + if (!getStructurePos(stype, ctx->mc, ctx->seed, rx, rz, &pos)) return vbool(false); + ensure_gen(ctx); + return vbool(isViableStructurePos(stype, ctx->gen, pos.x, pos.z, 0) != 0); +} + +static Val fn_struct_x(const Node *n, Ctx *ctx) { + if (n->nargs != 3) return verr("struct_x(type,rx,rz) takes 3 args"); + Val tv = eval_node(n->args[0], ctx); + if (tv.type != VT_STR) return verr("struct_x() arg 1 must be string"); + int stype = parse_stype(tv.s); + if (stype < 0) return verr("struct_x(): unknown structure type"); + int rx, rz; + if (!arg_int(n,ctx,1,&rx) || !arg_int(n,ctx,2,&rz)) + return verr("struct_x() args 2,3 must be numbers"); + StructureConfig sc; + if (!getStructureConfig(stype, ctx->mc, &sc)) return vint(0); + Pos pos; + if (!getStructurePos(stype, ctx->mc, ctx->seed, rx, rz, &pos)) return vint(0); + return vint(pos.x); +} + +static Val fn_struct_z(const Node *n, Ctx *ctx) { + if (n->nargs != 3) return verr("struct_z(type,rx,rz) takes 3 args"); + Val tv = eval_node(n->args[0], ctx); + if (tv.type != VT_STR) return verr("struct_z() arg 1 must be string"); + int stype = parse_stype(tv.s); + if (stype < 0) return verr("struct_z(): unknown structure type"); + int rx, rz; + if (!arg_int(n,ctx,1,&rx) || !arg_int(n,ctx,2,&rz)) + return verr("struct_z() args 2,3 must be numbers"); + StructureConfig sc; + if (!getStructureConfig(stype, ctx->mc, &sc)) return vint(0); + Pos pos; + if (!getStructurePos(stype, ctx->mc, ctx->seed, rx, rz, &pos)) return vint(0); + return vint(pos.z); +} + +static Val fn_spawn(const Node *n, Ctx *ctx, bool want_z) { + if (n->nargs != 0) return verr("spawn_x()/spawn_z() take no args"); + ensure_gen(ctx); + if (!ctx->spawn_ready) { + ctx->spawn = getSpawn(ctx->gen); + ctx->spawn_ready = true; + } + return vint(want_z ? ctx->spawn.z : ctx->spawn.x); +} + +/* ============================================================ + * AST evaluator + * ========================================================== */ + +static Val eval_node(const Node *n, Ctx *ctx) { + if (!n) return verr("null node"); + + switch (n->k) { + case ND_INT: return vint(n->ival); + case ND_FLOAT: return vfloat(n->dval); + case ND_STR: return vstr(n->name); + case ND_BOOL: return vbool(n->bval); + + case ND_VAR: + if (!strcmp(n->name,"seed")) return vint((int64_t)ctx->seed); + { char buf[SMAX]; snprintf(buf,SMAX,"unknown variable '%s'",n->name); return verr(buf); } + + case ND_CALL: + if (!strcmp(n->name,"biome")) return fn_biome(n,ctx); + if (!strcmp(n->name,"biome_id")) return fn_biome_id(n,ctx); + if (!strcmp(n->name,"has_biome")) return fn_has_biome(n,ctx); + if (!strcmp(n->name,"structure")) return fn_structure(n,ctx); + if (!strcmp(n->name,"struct_x")) return fn_struct_x(n,ctx); + if (!strcmp(n->name,"struct_z")) return fn_struct_z(n,ctx); + if (!strcmp(n->name,"spawn_x")) return fn_spawn(n,ctx,false); + if (!strcmp(n->name,"spawn_z")) return fn_spawn(n,ctx,true); + { char buf[SMAX]; snprintf(buf,SMAX,"unknown function '%s'",n->name); return verr(buf); } + + case ND_NOT: { + Val v = eval_node(n->lhs,ctx); + return (v.type==VT_ERR) ? v : vbool(!vtrue(v)); + } + case ND_NEG: { + Val v = eval_node(n->lhs,ctx); + if (v.type==VT_INT) return vint(-v.i); + if (v.type==VT_FLOAT) return vfloat(-v.d); + return verr("unary minus on non-numeric"); + } + + case ND_ADD: case ND_SUB: case ND_MUL: case ND_DIV: case ND_MOD: { + Val a=eval_node(n->lhs,ctx), b=eval_node(n->rhs,ctx); + if (a.type==VT_ERR) return a; + if (b.type==VT_ERR) return b; + if (a.type==VT_INT && b.type==VT_INT) { + int64_t ai=a.i, bi=b.i; + switch (n->k) { + case ND_ADD: return vint(ai+bi); + case ND_SUB: return vint(ai-bi); + case ND_MUL: return vint(ai*bi); + case ND_DIV: return bi ? vint(ai/bi) : verr("division by zero"); + default: return bi ? vint(ai%bi) : verr("modulo by zero"); + } + } + double da=(a.type==VT_INT)?(double)a.i:a.d; + double db=(b.type==VT_INT)?(double)b.i:b.d; + switch (n->k) { + case ND_ADD: return vfloat(da+db); + case ND_SUB: return vfloat(da-db); + case ND_MUL: return vfloat(da*db); + default: return db ? vfloat(da/db) : verr("division by zero"); + } + } + + case ND_LT: case ND_LE: case ND_GT: case ND_GE: { + Val a=eval_node(n->lhs,ctx), b=eval_node(n->rhs,ctx); + if (a.type==VT_ERR) return a; + if (b.type==VT_ERR) return b; + int c=vcmp(a,b); + switch (n->k) { + case ND_LT: return vbool(c<0); + case ND_LE: return vbool(c<=0); + case ND_GT: return vbool(c>0); + default: return vbool(c>=0); + } + } + case ND_EQ: { + Val a=eval_node(n->lhs,ctx), b=eval_node(n->rhs,ctx); + if (a.type==VT_ERR) return a; + if (b.type==VT_ERR) return b; + return vbool(veq(a,b)); + } + case ND_NEQ: { + Val a=eval_node(n->lhs,ctx), b=eval_node(n->rhs,ctx); + if (a.type==VT_ERR) return a; + if (b.type==VT_ERR) return b; + return vbool(!veq(a,b)); + } + + case ND_AND: { + Val a=eval_node(n->lhs,ctx); + if (a.type==VT_ERR) return a; + if (!vtrue(a)) return vbool(false); + Val b=eval_node(n->rhs,ctx); + return (b.type==VT_ERR) ? b : vbool(vtrue(b)); + } + case ND_OR: { + Val a=eval_node(n->lhs,ctx); + if (a.type==VT_ERR) return a; + if (vtrue(a)) return vbool(true); + Val b=eval_node(n->rhs,ctx); + return (b.type==VT_ERR) ? b : vbool(vtrue(b)); + } + + default: + return verr("unknown node kind"); + } +} + +/* ============================================================ + * xorshift64 for random seed generation + * ========================================================== */ +static uint64_t xorshift64(uint64_t s) { + s ^= s << 13; + s ^= s >> 7; + s ^= s << 17; + return s; +} + +/* ============================================================ + * Usage + * ========================================================== */ +static void usage(const char *prog) { + printf( +"Usage: %s [OPTIONS]\n" +"\n" +"Options:\n" +" --mc VERSION Minecraft version (default: newest, e.g. 1.21, 1.18, 1.7, b1.8)\n" +" --filter EXPR CEL filter expression (default: accept all seeds)\n" +" --count N Stop after N matches (default: 10)\n" +" --from SEED Starting seed, signed int64 (default: 0)\n" +" --to SEED Ending seed exclusive (default: unlimited)\n" +" --step N Seed increment (default: 1)\n" +" --random Use random seeds instead of sequential\n" +" --dim DIM Dimension: overworld|nether|end (default: overworld)\n" +" --large Use large biomes flag\n" +" --quiet Print only seed values, no labels\n" +" --verbose Print seed index alongside value\n" +" --list-versions Print supported Minecraft versions and exit\n" +" --help, -h Show this help and exit\n" +"\n" +"Filter functions (x,z are block coordinates; rx,rz are region indices):\n" +" biome(x, z) biome name at block coords -> string\n" +" biome_id(x, z) biome numeric ID -> int\n" +" has_biome(name, x, z, r) biome present within r blocks -> bool\n" +" structure(type, rx, rz) viable structure at region -> bool\n" +" struct_x(type, rx, rz) structure block X coord -> int\n" +" struct_z(type, rx, rz) structure block Z coord -> int\n" +" spawn_x() world spawn X coordinate -> int\n" +" spawn_z() world spawn Z coordinate -> int\n" +"\n" +"Filter variable:\n" +" seed current seed (int64)\n" +"\n" +"Structure types:\n" +" village mansion monument outpost desert_pyramid jungle_temple\n" +" swamp_hut igloo ocean_ruin shipwreck ruined_portal ancient_city\n" +" fortress bastion end_city stronghold trail_ruins trial_chambers\n" +"\n" +"Examples:\n" +" %s --mc 1.21 --filter 'biome(0,0) == \"jungle\"'\n" +" %s --mc 1.18 --filter 'has_biome(\"mushroom_fields\",0,0,500)' --count 5\n" +" %s --mc 1.16 --filter 'structure(\"village\",0,0) && structure(\"mansion\",1,0)'\n" +" %s --random --filter 'spawn_x() > -100 && spawn_x() < 100'\n" +" %s --from -100000 --to 100000 --filter 'seed %% 7 == 0' --count 20\n" +"\n", prog, prog, prog, prog, prog, prog); +} + +static void list_versions(void) { + printf("Supported Minecraft versions:\n"); + for (int mc = MC_B1_7; mc <= MC_NEWEST; mc++) { + const char *v = mc2str(mc); + if (v && strcmp(v,"?")!=0) printf(" %s\n", v); + } +} + +/* ============================================================ + * Main + * ========================================================== */ +int main(int argc, char **argv) { + int mc = MC_NEWEST; + const char *filter = NULL; + uint64_t count = 10; + int64_t from_s = 0; + int64_t to_s = 0; + bool has_to = false; + int64_t step = 1; + bool random_m = false; + int dim = DIM_OVERWORLD; + uint32_t flags = 0; + bool quiet = false; + bool verbose = false; + + for (int i = 1; i < argc; i++) { + if (!strcmp(argv[i],"--mc") && i+1 0\n"); return 1; } + } else if (!strcmp(argv[i],"--random")) { + random_m = true; + } else if (!strcmp(argv[i],"--dim") && i+1