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 <noreply@anthropic.com>
This commit is contained in:
Arigadam 2026-10-13 09:27:20 +00:00
commit 843f1ce8f3
8 changed files with 1286 additions and 0 deletions

2
.gitignore vendored Normal file
View file

@ -0,0 +1,2 @@
celseed
*.o

6
.gitmodules vendored Normal file
View file

@ -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

21
LICENSE Normal file
View file

@ -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.

37
Makefile Normal file
View file

@ -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)

254
README.md Normal file
View file

@ -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 <repo-url>
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).
---
<a name="russian"></a>
# celseed (Русский)
Поиск сидов Minecraft для всех версий. Задайте фильтр — программа напечатает подходящие сиды.
---
## Сборка
Требуется: `gcc`, `make`, `libm`.
```
git clone --recurse-submodules <url-репозитория>
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).

1
cel-c Submodule

@ -0,0 +1 @@
Subproject commit d2790407db22c857a24f659e10a2906d23bf0e6d

964
celseed.c Normal file
View file

@ -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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <stdint.h>
#include <stdbool.h>
#include <inttypes.h>
#include <time.h>
#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<argc) {
mc = str2mc(argv[++i]);
if (mc == MC_UNDEF) {
fprintf(stderr,"Unknown version '%s'. Use --list-versions.\n",argv[i]);
return 1;
}
} else if (!strcmp(argv[i],"--filter") && i+1<argc) {
filter = argv[++i];
} else if (!strcmp(argv[i],"--count") && i+1<argc) {
count = (uint64_t)strtoull(argv[++i], NULL, 10);
} else if (!strcmp(argv[i],"--from") && i+1<argc) {
from_s = strtoll(argv[++i], NULL, 10);
} else if (!strcmp(argv[i],"--to") && i+1<argc) {
to_s = strtoll(argv[++i], NULL, 10);
has_to = true;
} else if (!strcmp(argv[i],"--step") && i+1<argc) {
step = strtoll(argv[++i], NULL, 10);
if (step <= 0) { fprintf(stderr,"--step must be > 0\n"); return 1; }
} else if (!strcmp(argv[i],"--random")) {
random_m = true;
} else if (!strcmp(argv[i],"--dim") && i+1<argc) {
++i;
if (!strcmp(argv[i],"overworld")) dim = DIM_OVERWORLD;
else if (!strcmp(argv[i],"nether")) dim = DIM_NETHER;
else if (!strcmp(argv[i],"end")) dim = DIM_END;
else { fprintf(stderr,"Unknown dim '%s'\n",argv[i]); return 1; }
} else if (!strcmp(argv[i],"--large")) {
flags |= LARGE_BIOMES;
} else if (!strcmp(argv[i],"--quiet")) {
quiet = true;
} else if (!strcmp(argv[i],"--verbose")) {
verbose = true;
} else if (!strcmp(argv[i],"--list-versions")) {
list_versions();
return 0;
} else if (!strcmp(argv[i],"--help") || !strcmp(argv[i],"-h")) {
usage(argv[0]);
return 0;
} else {
fprintf(stderr,"Unknown option '%s'. Use --help.\n",argv[i]);
return 1;
}
}
/* Parse filter expression */
Parser parser;
Node *ast = NULL;
if (filter) {
memset(&parser, 0, sizeof(parser));
lex_init(&parser.lex, filter);
ast = parse_expr(&parser);
if (!ast || parser.err[0]) {
fprintf(stderr,"Filter parse error: %s\n",
parser.err[0] ? parser.err : "unknown");
return 1;
}
if (lpeek(&parser.lex).k != TK_EOF) {
fprintf(stderr,"Filter parse error: unexpected trailing input\n");
return 1;
}
}
if (!quiet) {
fprintf(stderr,"# celseed mc=%s dim=%d count=%"PRIu64" filter=%s\n",
mc2str(mc), dim, count, filter ? filter : "(none)");
}
/* Set up generator (once for the mc version / flags) */
Generator gen;
setupGenerator(&gen, mc, flags);
/* Initialize RNG for random mode */
uint64_t rng = (uint64_t)time(NULL) ^ (uint64_t)(uintptr_t)&rng;
if (rng == 0) rng = 1;
rng = xorshift64(rng);
uint64_t seed = (uint64_t)from_s;
uint64_t found = 0;
uint64_t tested = 0;
while (found < count) {
if (!random_m && has_to && (int64_t)seed == to_s) break;
bool match = true;
if (ast) {
Ctx ctx;
ctx.seed = seed;
ctx.mc = mc;
ctx.dim = dim;
ctx.flags = flags;
ctx.gen = &gen;
ctx.gen_ready = false;
ctx.spawn_ready = false;
ctx.spawn.x = ctx.spawn.z = 0;
Val r = eval_node(ast, &ctx);
if (r.type == VT_ERR) {
fprintf(stderr,"# filter error seed=%"PRId64": %s\n",
(int64_t)seed, r.s);
match = false;
} else {
match = vtrue(r);
}
}
if (match) {
found++;
if (quiet) {
printf("%"PRId64"\n", (int64_t)seed);
} else if (verbose) {
printf("%-22"PRId64" [%"PRIu64"/%"PRIu64"]\n",
(int64_t)seed, found, count);
} else {
printf("%"PRId64"\n", (int64_t)seed);
}
fflush(stdout);
}
tested++;
if (random_m) {
rng = xorshift64(rng);
seed = rng;
} else {
seed = (uint64_t)((int64_t)seed + step);
}
}
if (!quiet)
fprintf(stderr,"# done tested=%"PRIu64" found=%"PRIu64"\n", tested, found);
return 0;
}

1
cubiomes Submodule

@ -0,0 +1 @@
Subproject commit 4f04235f3e6e25491a02a830e4f500f68045be17