/* * 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