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:
commit
843f1ce8f3
8 changed files with 1286 additions and 0 deletions
2
.gitignore
vendored
Normal file
2
.gitignore
vendored
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
celseed
|
||||
*.o
|
||||
6
.gitmodules
vendored
Normal file
6
.gitmodules
vendored
Normal 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
21
LICENSE
Normal 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
37
Makefile
Normal 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
254
README.md
Normal 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
1
cel-c
Submodule
|
|
@ -0,0 +1 @@
|
|||
Subproject commit d2790407db22c857a24f659e10a2906d23bf0e6d
|
||||
964
celseed.c
Normal file
964
celseed.c
Normal 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
1
cubiomes
Submodule
|
|
@ -0,0 +1 @@
|
|||
Subproject commit 4f04235f3e6e25491a02a830e4f500f68045be17
|
||||
Loading…
Add table
Add a link
Reference in a new issue