Seeds are written one per line, flushed immediately on each match. --append opens the file in append mode instead of overwriting. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
866 lines
38 KiB
C
866 lines
38 KiB
C
/*
|
||
* 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 <stdarg.h>
|
||
#include <time.h>
|
||
#include <unistd.h>
|
||
#include <sys/ioctl.h>
|
||
|
||
#include "deps/log.c/src/log.h"
|
||
#include "cubiomes/generator.h"
|
||
#include "cubiomes/finders.h"
|
||
#include "cubiomes/biomes.h"
|
||
#include "cubiomes/util.h"
|
||
|
||
/* ============================================================
|
||
* ANSI codes + Unicode glyphs
|
||
* ========================================================== */
|
||
#define C_RESET "\033[0m"
|
||
#define C_BOLD "\033[1m"
|
||
#define C_GREEN "\033[32m"
|
||
#define C_BGREEN "\033[1;32m"
|
||
#define C_CYAN "\033[36m"
|
||
#define C_YELLOW "\033[33m"
|
||
#define C_RED "\033[31m"
|
||
#define C_MAGENTA "\033[35m"
|
||
#define C_GRAY "\033[90m"
|
||
#define C_BLUE "\033[94m"
|
||
|
||
#define PIPE "\xe2\x94\x82" /* │ U+2502 */
|
||
#define BAR_FULL "\xe2\x96\x88" /* █ U+2588 */
|
||
#define BAR_LITE "\xe2\x96\x91" /* ░ U+2591 */
|
||
|
||
static const char *SPIN[] = { /* braille spinner */
|
||
"\xe2\xa0\x8b", "\xe2\xa0\x99", "\xe2\xa0\xb9", "\xe2\xa0\xb8",
|
||
"\xe2\xa0\xbc", "\xe2\xa0\xb4", "\xe2\xa0\xa6", "\xe2\xa0\xa7",
|
||
"\xe2\xa0\x87", "\xe2\xa0\x8f"
|
||
};
|
||
#define SPIN_N 10
|
||
|
||
/* ============================================================
|
||
* CEL 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;
|
||
} 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, 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';
|
||
while (l->src[l->pos]==' '||l->src[l->pos]=='\t') l->pos++;
|
||
char c=l->src[l->pos];
|
||
if (!c) { t.k=TK_EOF; return t; }
|
||
if (c=='"') {
|
||
l->pos++; int i=0;
|
||
while (l->src[l->pos]&&l->src[l->pos]!='"'&&i<SMAX-1) t.sval[i++]=l->src[l->pos++];
|
||
t.sval[i]='\0'; if (l->src[l->pos]=='"') l->pos++; t.k=TK_STR; return t;
|
||
}
|
||
if (c>='0'&&c<='9') {
|
||
char *end; t.ival=strtoll(l->src+l->pos,&end,10);
|
||
if (*end=='.'||*end=='e'||*end=='E') { t.dval=strtod(l->src+l->pos,&end); t.k=TK_FLOAT; }
|
||
else t.k=TK_INT;
|
||
l->pos=(int)(end-l->src); return t;
|
||
}
|
||
if ((c>='a'&&c<='z')||(c>='A'&&c<='Z')||c=='_') {
|
||
int i=0;
|
||
while ((l->src[l->pos]>='a'&&l->src[l->pos]<='z')||(l->src[l->pos]>='A'&&l->src[l->pos]<='Z')||
|
||
(l->src[l->pos]>='0'&&l->src[l->pos]<='9')||l->src[l->pos]=='_')
|
||
t.sval[i++]=l->src[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(l->src[l->pos]=='='){l->pos++;t.k=TK_NEQ;}else t.k=TK_BANG; break;
|
||
case '<': if(l->src[l->pos]=='='){l->pos++;t.k=TK_LE;} else t.k=TK_LT; break;
|
||
case '>': if(l->src[l->pos]=='='){l->pos++;t.k=TK_GE;} else t.k=TK_GT; break;
|
||
case '=': if(l->src[l->pos]=='='){l->pos++;t.k=TK_EQ;} else{snprintf(l->err,SMAX,"use '=='");t.k=TK_ERR;} break;
|
||
case '&': if(l->src[l->pos]=='&'){l->pos++;t.k=TK_AND;}else{snprintf(l->err,SMAX,"use '&&'");t.k=TK_ERR;} break;
|
||
case '|': if(l->src[l->pos]=='|'){l->pos++;t.k=TK_OR;} else{snprintf(l->err,SMAX,"use '||'");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");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 ')'");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 '%s' (kind=%d)",t.sval,t.k);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);
|
||
|
||
static const char *strip_ns(const char *s){ return (s&&!strncmp(s,"minecraft:",10))?s+10:s; }
|
||
static bool biome_name_eq(const char *q,const char *r){
|
||
if(!r) return false; return strcasecmp(strip_ns(q),strip_ns(r))==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); return vint(getBiomeAt(ctx->gen,4,x>>2,0,z>>2));}
|
||
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-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){
|
||
for(int id=0;id<256;id++){const char *nm=biome2str(ctx->mc,id);if(biome_name_eq(bval.s,nm)){target=id;break;}}
|
||
if(target<0){
|
||
static const struct{const char *n;int v;} 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},{NULL,0}};
|
||
for(int i=0;tbl[i].n;i++) if(strcasecmp(tbl[i].n,bval.s)==0){target=tbl[i].v;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, cx4=cx>>2, cz4=cz>>2, 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;} m[]={
|
||
{"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;m[i].n;i++) if(strcasecmp(m[i].n,s)==0) return m[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 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_coord(const Node *n,Ctx *ctx,bool want_z){
|
||
if(n->nargs!=3) return verr("struct_x/z(type,rx,rz) takes 3 args");
|
||
Val tv=eval_node(n->args[0],ctx);if(tv.type!=VT_STR) return verr("struct_x/z() arg 1 must be string");
|
||
int stype=parse_stype(tv.s);if(stype<0) return verr("struct_x/z(): unknown type");
|
||
int rx,rz;if(!arg_int(n,ctx,1,&rx)||!arg_int(n,ctx,2,&rz)) return verr("struct_x/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(want_z?pos.z:pos.x);}
|
||
static Val fn_spawn(const Node *n,Ctx *ctx,bool want_z){
|
||
if(n->nargs!=0) return verr("spawn_x/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: { Val r; memset(&r,0,sizeof(r)); r.type=VT_BOOL; r.b=n->bval; return r; }
|
||
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_coord(n,ctx,false);
|
||
if(!strcmp(n->name,"struct_z")) return fn_struct_coord(n,ctx,true);
|
||
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("div/0");
|
||
default:return bi?vint(ai%bi):verr("mod/0");}}
|
||
double da=(a.type==VT_INT)?(double)a.i:a.d,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("div/0");}}
|
||
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");
|
||
}
|
||
}
|
||
|
||
/* ============================================================
|
||
* Time utilities
|
||
* ========================================================== */
|
||
static double now_s(void) {
|
||
struct timespec ts;
|
||
clock_gettime(CLOCK_MONOTONIC, &ts);
|
||
return (double)ts.tv_sec + (double)ts.tv_nsec * 1e-9;
|
||
}
|
||
|
||
static void fmt_speed(char *buf, int sz, double s) {
|
||
if (s>=1e9) snprintf(buf,sz,"%.2fG/s",s/1e9);
|
||
else if (s>=1e6) snprintf(buf,sz,"%.2fM/s",s/1e6);
|
||
else if (s>=1e3) snprintf(buf,sz,"%.1fK/s",s/1e3);
|
||
else snprintf(buf,sz,"%.0f/s",s);
|
||
}
|
||
static void fmt_count(char *buf, int sz, uint64_t n) {
|
||
if (n>=1000000000) snprintf(buf,sz,"%.2fB",n/1e9);
|
||
else if (n>=1000000) snprintf(buf,sz,"%.2fM",n/1e6);
|
||
else if (n>=1000) snprintf(buf,sz,"%.1fK",n/1e3);
|
||
else snprintf(buf,sz,"%"PRIu64,n);
|
||
}
|
||
static void fmt_eta(char *buf, int sz, double secs) {
|
||
if(secs<0||secs>86400*7){snprintf(buf,sz,"?");return;}
|
||
int h=(int)(secs/3600),m=(int)(secs/60)%60,s=(int)secs%60;
|
||
if(h>0) snprintf(buf,sz,"%d:%02d:%02d",h,m,s);
|
||
else snprintf(buf,sz,"%d:%02d",m,s);
|
||
}
|
||
|
||
/* ============================================================
|
||
* Progress bar
|
||
* ========================================================== */
|
||
static struct {
|
||
bool enabled;
|
||
bool is_tty;
|
||
uint64_t count; /* target found (0 = unlimited) */
|
||
uint64_t tested;
|
||
uint64_t found;
|
||
double t_start;
|
||
double t_last_draw;
|
||
double t_speed_t; /* time of last speed sample */
|
||
uint64_t t_speed_n; /* tested count at last speed sample */
|
||
double speed; /* seeds/sec (EMA) */
|
||
int spin;
|
||
bool line_drawn;
|
||
} g_bar;
|
||
|
||
static int term_width(void) {
|
||
struct winsize ws;
|
||
if (isatty(STDERR_FILENO) && ioctl(STDERR_FILENO, TIOCGWINSZ, &ws)==0 && ws.ws_col>0)
|
||
return ws.ws_col;
|
||
return 80;
|
||
}
|
||
|
||
static void bar_clear(void) {
|
||
if (g_bar.line_drawn && g_bar.is_tty) {
|
||
fprintf(stderr, "\r\033[K"); fflush(stderr);
|
||
g_bar.line_drawn = false;
|
||
}
|
||
}
|
||
|
||
static void bar_draw(bool force) {
|
||
if (!g_bar.enabled) return;
|
||
double now = now_s();
|
||
if (!force && now - g_bar.t_last_draw < 0.08) return; /* ~12 fps */
|
||
|
||
/* update speed EMA every 250ms */
|
||
double dt = now - g_bar.t_speed_t;
|
||
if (dt >= 0.25) {
|
||
double inst = (g_bar.tested - g_bar.t_speed_n) / dt;
|
||
g_bar.speed = (g_bar.speed == 0.0) ? inst : g_bar.speed*0.75 + inst*0.25;
|
||
g_bar.t_speed_n = g_bar.tested;
|
||
g_bar.t_speed_t = now;
|
||
}
|
||
|
||
char spd[24], tst[16], fnd[24], eta[16];
|
||
fmt_speed(spd, sizeof(spd), g_bar.speed);
|
||
fmt_count(tst, sizeof(tst), g_bar.tested);
|
||
|
||
int tw = term_width();
|
||
|
||
if (g_bar.count > 0) {
|
||
/* determinate: show percentage bar */
|
||
int pct = (int)(g_bar.found * 100 / g_bar.count);
|
||
if (pct > 100) pct = 100;
|
||
|
||
/* ETA estimate */
|
||
double eta_secs = -1.0;
|
||
if (g_bar.found > 0 && g_bar.speed > 0.0) {
|
||
double avg = (double)g_bar.tested / (double)g_bar.found;
|
||
eta_secs = (double)(g_bar.count - g_bar.found) * avg / g_bar.speed;
|
||
}
|
||
fmt_eta(eta, sizeof(eta), eta_secs);
|
||
snprintf(fnd, sizeof(fnd), "%"PRIu64"/%"PRIu64, g_bar.found, g_bar.count);
|
||
|
||
/* fixed stats portion (visual width): " 100% │ Found XX/XX │ 99.99M/s │ ETA 9:99:99" */
|
||
char stats_plain[80];
|
||
snprintf(stats_plain, sizeof(stats_plain),
|
||
" %d%% " PIPE " Found %s " PIPE " %s " PIPE " ETA %s",
|
||
pct, fnd, spd, eta);
|
||
/* visual width: each │ is 3 bytes but 1 column, so subtract 2 per │ (3 occurrences) */
|
||
int stats_vw = (int)strlen(stats_plain) - 2*3;
|
||
|
||
int prefix_vw = 11; /* "Searching " */
|
||
int bar_vw = tw - prefix_vw - stats_vw;
|
||
if (bar_vw < 6) bar_vw = 6;
|
||
if (bar_vw > 45) bar_vw = 45;
|
||
|
||
int filled = (g_bar.count > 0) ? (int)((double)g_bar.found / g_bar.count * bar_vw) : 0;
|
||
if (filled > bar_vw) filled = bar_vw;
|
||
|
||
/* build bar (each char = 3 UTF-8 bytes) */
|
||
char bar_str[45*3+1]; int blen=0;
|
||
for (int i=0;i<bar_vw;i++) {
|
||
const char *ch = (i<filled) ? BAR_FULL : BAR_LITE;
|
||
memcpy(bar_str+blen, ch, 3); blen+=3;
|
||
}
|
||
bar_str[blen]='\0';
|
||
|
||
if (g_bar.is_tty) {
|
||
fprintf(stderr,
|
||
"\r" C_BGREEN "Searching" C_RESET " "
|
||
C_GREEN "%s" C_RESET
|
||
" " C_BOLD "%d%%" C_RESET
|
||
" " PIPE " Found " C_BGREEN "%s" C_RESET
|
||
" " PIPE " " C_CYAN "%s" C_RESET
|
||
" " PIPE " ETA " C_YELLOW "%s" C_RESET,
|
||
bar_str, pct, fnd, spd, eta);
|
||
} else {
|
||
fprintf(stderr, "\rSearching [%d%%] Found %s %s ETA %s",
|
||
pct, fnd, spd, eta);
|
||
}
|
||
} else {
|
||
/* indeterminate spinner */
|
||
g_bar.spin = (g_bar.spin + 1) % SPIN_N;
|
||
snprintf(fnd, sizeof(fnd), "%"PRIu64, g_bar.found);
|
||
if (g_bar.is_tty) {
|
||
fprintf(stderr,
|
||
"\r" C_BGREEN "Searching" C_RESET " "
|
||
C_GREEN "%s" C_RESET " "
|
||
"Tested " C_CYAN "%s" C_RESET " " PIPE " "
|
||
"Found " C_BGREEN "%s" C_RESET " " PIPE " "
|
||
C_CYAN "%s" C_RESET,
|
||
SPIN[g_bar.spin], tst, fnd, spd);
|
||
} else {
|
||
fprintf(stderr, "\rSearching [%s] Tested %s Found %s %s",
|
||
SPIN[g_bar.spin], tst, fnd, spd);
|
||
}
|
||
}
|
||
fprintf(stderr, "\033[K"); /* erase any leftover from previous longer line */
|
||
fflush(stderr);
|
||
g_bar.line_drawn = true;
|
||
g_bar.t_last_draw = now;
|
||
}
|
||
|
||
static void bar_finish(uint64_t tested, uint64_t found, double elapsed) {
|
||
bar_clear();
|
||
char spd[24], tst[16], ela[16];
|
||
fmt_speed(spd, sizeof(spd), elapsed>0 ? tested/elapsed : 0);
|
||
fmt_count(tst, sizeof(tst), tested);
|
||
int h=(int)(elapsed/3600),m=(int)(elapsed/60)%60,s=(int)elapsed%60;
|
||
if(h>0) snprintf(ela,sizeof(ela),"%d:%02d:%02d",h,m,s);
|
||
else snprintf(ela,sizeof(ela),"%d:%02d",m,s);
|
||
if (g_bar.is_tty) {
|
||
fprintf(stderr,
|
||
C_BGREEN "Done" C_RESET
|
||
" " C_BGREEN "✓" C_RESET
|
||
" Found " C_BGREEN "%"PRIu64 C_RESET
|
||
" " PIPE " Tested " C_CYAN "%s" C_RESET
|
||
" " PIPE " " C_CYAN "%s" C_RESET
|
||
" " PIPE " Elapsed " C_YELLOW "%s" C_RESET "\n",
|
||
found, tst, spd, ela);
|
||
} else {
|
||
fprintf(stderr, "Done Found %"PRIu64" Tested %s %s Elapsed %s\n",
|
||
found, tst, spd, ela);
|
||
}
|
||
fflush(stderr);
|
||
}
|
||
|
||
/* ============================================================
|
||
* log.c callback: clears progress bar before and redraws after
|
||
* ========================================================== */
|
||
static void log_stderr_cb(log_Event *ev) {
|
||
static const char *colors[] = {
|
||
C_GRAY, C_BLUE, C_GREEN, C_YELLOW, C_RED, C_MAGENTA
|
||
};
|
||
static const char *labels[] = {
|
||
"TRACE", "DEBUG", "INFO ", "WARN ", "ERROR", "FATAL"
|
||
};
|
||
|
||
bar_clear();
|
||
|
||
char ts[10];
|
||
strftime(ts, sizeof(ts), "%H:%M:%S", ev->time);
|
||
|
||
FILE *fp = (FILE *)ev->udata;
|
||
if (g_bar.is_tty) {
|
||
fprintf(fp, "%s %s%s" C_RESET " ", ts, colors[ev->level], labels[ev->level]);
|
||
} else {
|
||
fprintf(fp, "%s %s ", ts, labels[ev->level]);
|
||
}
|
||
vfprintf(fp, ev->fmt, ev->ap);
|
||
fputc('\n', fp);
|
||
fflush(fp);
|
||
|
||
bar_draw(true);
|
||
}
|
||
|
||
static void log_file_cb(log_Event *ev) {
|
||
static const char *labels[] = {"TRACE","DEBUG","INFO ","WARN ","ERROR","FATAL"};
|
||
char ts[24];
|
||
strftime(ts, sizeof(ts), "%Y-%m-%d %H:%M:%S", ev->time);
|
||
FILE *fp = (FILE *)ev->udata;
|
||
fprintf(fp, "%s %s ", ts, labels[ev->level]);
|
||
vfprintf(fp, ev->fmt, ev->ap);
|
||
fputc('\n', fp);
|
||
fflush(fp);
|
||
}
|
||
|
||
/* ============================================================
|
||
* xorshift64
|
||
* ========================================================== */
|
||
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)\n"
|
||
" --filter EXPR CEL filter expression\n"
|
||
" --count N Stop after N matches (default: 10)\n"
|
||
" --from SEED Starting seed (signed int64, default: 0)\n"
|
||
" --to SEED Ending seed exclusive\n"
|
||
" --step N Seed increment (default: 1)\n"
|
||
" --random Random seeds instead of sequential\n"
|
||
" --dim overworld|nether|end Dimension (default: overworld)\n"
|
||
" --large Enable large biomes\n"
|
||
" --quiet Print only seed values to stdout\n"
|
||
" --verbose Print seed index alongside value\n"
|
||
" --output FILE, -o Write matched seeds to FILE (one per line)\n"
|
||
" --append Append to output file instead of overwriting\n"
|
||
" --log-level LEVEL trace|debug|info|warn|error|off (default: info)\n"
|
||
" --log-file FILE Write logs to FILE in addition to stderr\n"
|
||
" --no-progress Disable progress bar\n"
|
||
" --progress Force-enable progress bar\n"
|
||
" --list-versions Print supported MC versions and exit\n"
|
||
" --help, -h Show this help\n\n"
|
||
"Filter functions (x,z=block coords; rx,rz=region indices):\n"
|
||
" biome(x,z) biome name -> string\n"
|
||
" biome_id(x,z) biome ID -> int\n"
|
||
" has_biome(name,x,z,r) biome within r blocks -> bool\n"
|
||
" structure(type,rx,rz) viable structure -> bool\n"
|
||
" struct_x/z(type,rx,rz) structure coordinate -> int\n"
|
||
" spawn_x() / spawn_z() world spawn coords -> int\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\n",
|
||
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;
|
||
int log_level = LOG_INFO;
|
||
const char *log_file = NULL;
|
||
const char *out_file = NULL;
|
||
bool out_append = false;
|
||
int prog_force = 0; /* 0=auto, 1=on, -1=off */
|
||
|
||
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'\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],"--log-level") &&i+1<argc) {
|
||
++i;
|
||
if (!strcmp(argv[i],"trace")) log_level=LOG_TRACE;
|
||
else if (!strcmp(argv[i],"debug")) log_level=LOG_DEBUG;
|
||
else if (!strcmp(argv[i],"info")) log_level=LOG_INFO;
|
||
else if (!strcmp(argv[i],"warn")) log_level=LOG_WARN;
|
||
else if (!strcmp(argv[i],"error")) log_level=LOG_ERROR;
|
||
else if (!strcmp(argv[i],"off")) log_level=LOG_FATAL+1;
|
||
else { fprintf(stderr,"Unknown log level '%s'\n",argv[i]); return 1; }
|
||
}
|
||
else if (!strcmp(argv[i],"--log-file") &&i+1<argc) { log_file=argv[++i]; }
|
||
else if (!strcmp(argv[i],"--output")||!strcmp(argv[i],"-o")) {
|
||
if (i+1>=argc) { fprintf(stderr,"--output requires a filename\n"); return 1; }
|
||
out_file=argv[++i];
|
||
}
|
||
else if (!strcmp(argv[i],"--append")) { out_append=true; }
|
||
else if (!strcmp(argv[i],"--no-progress")) { prog_force=-1; }
|
||
else if (!strcmp(argv[i],"--progress")) { prog_force=1; }
|
||
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; }
|
||
}
|
||
|
||
/* Set up logging */
|
||
log_set_quiet(true);
|
||
log_set_level(log_level);
|
||
bool stderr_is_tty = isatty(STDERR_FILENO);
|
||
log_add_callback(log_stderr_cb, stderr, log_level);
|
||
|
||
FILE *log_fp = NULL;
|
||
if (log_file) {
|
||
log_fp = fopen(log_file, "a");
|
||
if (!log_fp) { perror(log_file); return 1; }
|
||
log_add_callback(log_file_cb, log_fp, LOG_TRACE);
|
||
}
|
||
|
||
FILE *out_fp = NULL;
|
||
if (out_file) {
|
||
out_fp = fopen(out_file, out_append ? "a" : "w");
|
||
if (!out_fp) { perror(out_file); return 1; }
|
||
log_debug("output file: %s (%s)", out_file, out_append ? "append" : "overwrite");
|
||
}
|
||
|
||
/* Set up progress bar */
|
||
g_bar.is_tty = (prog_force == 1) || (prog_force == 0 && stderr_is_tty);
|
||
g_bar.enabled = (prog_force >= 0) && (prog_force == 1 || stderr_is_tty);
|
||
g_bar.count = count;
|
||
g_bar.t_start = now_s();
|
||
g_bar.t_speed_t = g_bar.t_start;
|
||
|
||
/* 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]) {
|
||
log_error("filter parse error: %s", parser.err[0]?parser.err:"unknown");
|
||
return 1;
|
||
}
|
||
if (lpeek(&parser.lex).k != TK_EOF) {
|
||
log_error("filter parse error: unexpected trailing input");
|
||
return 1;
|
||
}
|
||
log_debug("filter parsed OK: %s", filter);
|
||
}
|
||
|
||
log_info("mc=%s dim=%d count=%"PRIu64" filter=%s",
|
||
mc2str(mc), dim, count, filter?filter:"(none)");
|
||
if (has_to) log_debug("range: [%"PRId64", %"PRId64")", from_s, to_s);
|
||
if (random_m) log_debug("mode: random");
|
||
|
||
/* Set up generator */
|
||
Generator gen;
|
||
setupGenerator(&gen, mc, flags);
|
||
log_debug("generator ready: mc=%s flags=0x%x", mc2str(mc), flags);
|
||
|
||
/* RNG for random mode */
|
||
uint64_t rng = (uint64_t)now_s() ^ (uint64_t)(uintptr_t)argv;
|
||
if (!rng) rng = 0xdeadbeefcafe1234ULL;
|
||
for (int i=0; i<8; i++) rng = xorshift64(rng);
|
||
|
||
uint64_t seed = (uint64_t)from_s;
|
||
uint64_t found = 0;
|
||
uint64_t tested= 0;
|
||
|
||
/* Main search loop */
|
||
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) {
|
||
log_warn("filter error seed=%"PRId64": %s", (int64_t)seed, r.s);
|
||
match = false;
|
||
} else {
|
||
match = vtrue(r);
|
||
}
|
||
}
|
||
|
||
if (match) {
|
||
found++;
|
||
bar_clear();
|
||
if (quiet) {
|
||
printf("%"PRId64"\n", (int64_t)seed);
|
||
fflush(stdout);
|
||
} else if (verbose) {
|
||
printf("%-22"PRId64" [%"PRIu64"/%"PRIu64"]\n",
|
||
(int64_t)seed, found, count);
|
||
fflush(stdout);
|
||
} else {
|
||
printf("%"PRId64"\n", (int64_t)seed);
|
||
fflush(stdout);
|
||
}
|
||
if (out_fp) {
|
||
fprintf(out_fp, "%"PRId64"\n", (int64_t)seed);
|
||
fflush(out_fp);
|
||
}
|
||
log_info("found seed=%-20"PRId64" [%"PRIu64"/%"PRIu64"]",
|
||
(int64_t)seed, found, count);
|
||
g_bar.found = found;
|
||
bar_draw(true);
|
||
}
|
||
|
||
tested++;
|
||
g_bar.tested = tested;
|
||
|
||
/* refresh bar every 4096 seeds */
|
||
if ((tested & 0xFFF) == 0) bar_draw(false);
|
||
|
||
if (random_m) { rng=xorshift64(rng); seed=rng; }
|
||
else { seed=(uint64_t)((int64_t)seed+step); }
|
||
}
|
||
|
||
double elapsed = now_s() - g_bar.t_start;
|
||
log_info("done tested=%"PRIu64" found=%"PRIu64" elapsed=%.2fs", tested, found, elapsed);
|
||
bar_finish(tested, found, elapsed);
|
||
|
||
if (out_fp) {
|
||
fclose(out_fp);
|
||
log_info("seeds written to %s", out_file);
|
||
}
|
||
if (log_fp) fclose(log_fp);
|
||
return 0;
|
||
}
|