// Hyperbolic Rogue -- the 'experiments with geometry' menu // Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details /** \file geom-exp.cpp * \brief The 'experiments with geometry' menu * * Implementation of this menu, and computation of the statistics shown there */ #include "hyper.h" namespace hr { int eupage = 0; int euperpage = 21; string euchelp = "If you want to know how much the gameplay is affected by the " "hyperbolic geometry in HyperRogue, this mode is for you!\n\n" "You can try many different geometries here. We start by gluing " "n-gons in such a way that k of them meet in every vertex. " "Depending on n and k, this either folds into a sphere, unfolds into a plane, " "or requires a hyperbolic space. The result may be then 'bitrunc' by " "replacing each vertex by a 2k-gon. Furthermore, you can play " "with quotient geometries. For example, the elliptic geometry is " "obtained from the sphere by making the antipodes be the same point, " "so you return to the same spot (but as a mirror image) after going there. " "Have fun experimenting! " "Achievements and leaderboards do not work in geometry experiments, " "except some specific ones.\n\n" "In standard geometry (bitrunc or not), you can play the full game, but in other geometries " "you select a particular land. Lands are unlocked by visiting them in this " "session, or permanently by collecting 25 treasure. Try Crossroads in Euclidean " "or chaos mode in non-standard non-quotient hyperbolic to visit many lands. " "Highlights:\n" "* Crystal World and Warped Coast can be understood as extra geometries.\n" "* Halloween is specially designed for spherical geometry.\n" "* To see the difference, try Hunting Grounds in Euclidean -- it is impossible.\n"; #if CAP_FIELD void showQuotientConfig() { using namespace fieldpattern; gamescreen(2); dialog::init(XLAT("field quotient")); fgeomextra& gxcur = fgeomextras[current_extra]; for(int i=0; i= 25) landvisited[i] = true; landvisited[laCrossroads] = true; landvisited[laCrossroads4] = true; landvisited[laIce] = true; landvisited[laHunting] = true; landvisited[laMirrorOld] = true; landvisited[laPrincessQuest] = cheater || princess::everSaved; landvisited[laWildWest] = true; landvisited[laHalloween] = true; landvisited[laWarpCoast] = true; landvisited[laGraveyard] = true; landvisited[laDual] = true; landvisited[laDocks] |= landvisited[laWarpCoast]; landvisited[laSnakeNest] |= landvisited[laRedRock]; landvisited[laCamelot] |= hiitemsMax(treasureType(laCamelot)) >= 1; landvisited[laCA] = true; landvisited[laAsteroids] = true; dialog::init(XLAT("experiment with geometry")); // dialog::addSelItem(XLAT("geometry"), XLAT(bitruncnames[int(variation)]), '5'); // dialog::addBreak(50); generateLandList([] (eLand l) { return land_validity(l).flags & lv::appears_in_geom_exp; }); stable_sort(landlist.begin(), landlist.end(), [] (eLand l1, eLand l2) { return land_validity(l1).quality_level > land_validity(l2).quality_level; }); for(int i=0; i= isize(landlist)) { dialog::addBreak(100); break; } eLand l = landlist[euperpage * eupage + i]; char ch; if(i < 26) ch = 'a' + i; else ch = 'A' + (i-26); string s = XLAT1(linf[l].name); if(landvisited[l]) { dialog::addBoolItem(s, l == specialland, ch); } else { dialog::addSelItem(s, XLAT("(locked)"), ch); } dialog::lastItem().color = linf[l].color; dialog::lastItem().value += validclasses[land_validity(l).quality_level]; dialog::add_action([l] { if(landvisited[l]) dialog::do_if_confirmed(dual::mayboth([l] { stop_game_and_switch_mode(tactic::on ? rg::tactic : rg::nothing); firstland = specialland = l; if(l == laCanvas || l == laAsteroids) land_structure = lsSingle; else if(among(l, laCrossroads, laCrossroads2)) land_structure = lsNiceWalls; else if(among(l, laCrossroads4)) land_structure = lsNoWalls; start_game(); popScreen(); })); }); } dialog::addItem(XLAT("next page"), '-'); dialog::addBreak(25); validity_info(); dialog::addBreak(25); dual::add_choice(); dialog::addBack(); dialog::display(); keyhandler = [] (int sym, int uni) { dialog::handleNavigation(sym, uni); if(uni == '-' || uni == PSEUDOKEY_WHEELUP || uni == PSEUDOKEY_WHEELDOWN) { eupage++; if(eupage * euperpage >= isize(landlist)) eupage = 0; } else if(doexiton(sym, uni)) popScreen(); }; } #if HDR struct geometry_filter { string name; /** test if the current geometry matches the filter */ function test; }; #endif EX geometry_filter *current_filter; bool forced_quotient() { return quotient && !(cgflags & qOPTQ); } EX geometry_filter gf_hyperbolic = {"hyperbolic", [] { return (arcm::in() || arb::in() || hyperbolic) && !forced_quotient(); }}; EX geometry_filter gf_spherical = {"spherical", [] { return (arcm::in() || arb::in() || sphere) && !forced_quotient(); }}; EX geometry_filter gf_euclidean = {"Euclidean", [] { return (arcm::in() || arb::in() || euclid) && !forced_quotient(); }}; EX geometry_filter gf_other = {"non-isotropic", [] { return prod || nonisotropic; }}; EX geometry_filter gf_regular_2d = {"regular 2D tesselations", [] { return standard_tiling() && WDIM == 2 && !forced_quotient(); }}; EX geometry_filter gf_regular_3d = {"regular 3D honeycombs", [] { if(euclid) return geometry == gCubeTiling; return !bt::in() && !kite::in() && WDIM == 3 && !forced_quotient() && !nonisotropic && !prod; }}; EX geometry_filter gf_quotient = {"interesting quotient spaces", [] { return forced_quotient() && !elliptic; }}; vector available_filters = { &gf_hyperbolic, &gf_spherical, &gf_euclidean, &gf_other, &gf_regular_2d, &gf_regular_3d, &gf_quotient }; void ge_select_filter() { cmode = sm::SIDE | sm::MAYDARK; gamescreen(2); dialog::init(XLAT("geometries")); char x = 'a'; for(auto f: available_filters) { if(current_filter) dialog::addBoolItem(XLAT(f->name), f == current_filter, x++); else dialog::addItem(XLAT(f->name), x++); dialog::add_action([f] { current_filter = f; popScreen(); }); } dialog::addBack(); dialog::display(); } void set_default_filter() { current_filter = hyperbolic ? &gf_hyperbolic : euclid ? &gf_euclidean : sphere ? &gf_spherical : &gf_other; for(auto f: available_filters) if(f->test()) current_filter = f; } void set_or_configure_geometry(eGeometry g) { if(0) ; #if CAP_CRYSTAL else if(g == gCrystal) pushScreen(crystal::show); #endif #if CAP_ARCM else if(g == gArchimedean) pushScreen(arcm::show); #endif else if(g == gArbitrary) arb::choose(); else { if(among(g, gProduct, gRotSpace)) { if(WDIM == 3 || (g == gRotSpace && euclid)) { addMessage(XLAT( g == gRotSpace ? "Only works with 2D non-Euclidean geometries" : "Only works with 2D geometries" )); return; } if(g == gRotSpace) { bool ok = true; if(arcm::in()) ok = PURE; else if(bt::in() || kite::in()) ok = false; else ok = PURE || BITRUNCATED; if(!ok) { addMessage(XLAT("Only works with (semi-)regular tilings")); return; } #if CAP_ARCM if(arcm::in()) { int steps, single_step; if(!arcm::current.get_step_values(steps, single_step)) { addMessage(XLAT("That would have %1/%2 levels", its(steps), its(single_step))); return; } } #endif } } dual::may_split_or_do([g] { set_geometry(g); }); start_game(); } } /** is g2 the same tiling as the current geometry (geometry)? */ bool same_tiling(eGeometry g2) { if(g2 == gCrystal) return S3 == 4; if(g2 == gFieldQuotient && hyperbolic && standard_tiling()) return true; if(g2 == gFieldQuotient && geometry != gFieldQuotient) { int ce = 0; for(auto& ge: fieldpattern::fgeomextras) { if(ginf[ge.base].tiling_name == ginf[geometry].tiling_name) { fieldpattern::current_extra = ce; return true; } ce++; } } return ginf[g2].tiling_name == ginf[geometry].tiling_name; } void ge_select_tiling() { cmode = sm::SIDE | sm::MAYDARK; gamescreen(0); if(!current_filter) { popScreen(); return; } dialog::init(); dialog::addItem(XLAT(current_filter->name), 'x'); dialog::add_action_push(ge_select_filter); vector geometries; dialog::addBreak(100); char letter = 'a'; for(int i=0; i cg(geometry, g); if(cgflags & qDEPRECATED) continue; if(arcm::in() && !CAP_ARCM) continue; if(cryst && !CAP_CRYSTAL) continue; if(sol && !CAP_SOLV) continue; if(arb::in() && (ISMOBILE || ISWEB)) continue; if(WDIM == 3 && MAXMDIM == 3) continue; if(geometry == gFieldQuotient && !CAP_FIELD) continue; if(geometry == gFake) continue; if(!current_filter->test()) continue; if(orig_el) { for(int j=0; j= 999) return XLAT("orthographic projection"); else if(h && vpconf.alpha >= 999) return XLAT("Gans model"); else return XLAT("general perspective"); } EX string dim_name() { return " (" + its(WDIM) + "D)"; } #if CAP_THREAD && MAXMDIM >= 4 EX void showQuotientConfig3() { using namespace fieldpattern; gamescreen(2); dialog::init(XLAT("field quotient")); auto& ds = discoveries[cginf.tiling_name]; if(!ds.discoverer) { dialog::addItem("start discovery", 's'); dialog::add_action([&ds] { ds.activate(); }); } else if(ds.is_suspended) { dialog::addItem("resume discovery", 's'); dialog::add_action([&ds] { ds.activate(); }); } else { dialog::addItem("suspend discovery", 's'); dialog::add_action([&ds] { ds.suspend(); }); } auto& e = ds.experiment; if(!e.Prime) dialog::addBreak(100); else { string s = its(e.Prime); if(e.wsquare) s += "²"; dialog::addInfo(s); } dialog::addBreak(100); if(1) { std::unique_lock lk(ds.lock); auto&l = ds.hashes_found; for(auto& v: l) { char x = 'a'; string s = XLAT("#%1, cells: %2, p=%3", itsh(v.first), its(get<5>(v.second)), its(get<0>(v.second)) + (get<1>(v.second) ? "²" : "")); dialog::addItem(s, x++); dialog::add_action([&v] { stop_game(); int tmp; tie(currfp.Prime, currfp.wsquare, currfp.R, currfp.P, currfp.X, tmp) = v.second; currfp.Field = currfp.wsquare ? currfp.Prime * currfp.Prime : currfp.Prime; currfp.generate_all3(); currfp.analyze(); start_game(); }); } } dialog::addBreak(100); dialog::addBack(); dialog::display(); } #endif EX string geometry_name() { switch(ginf[geometry].cclass) { case gcHyperbolic: return XLAT("hyperbolic") + dim_name(); case gcEuclid: if(cgflags & qAFFINE) return XLAT("affine") + dim_name(); return XLAT("flat") + dim_name(); case gcSphere: return XLAT("spherical") + dim_name(); case gcSolNIH: #if CAP_SOLV switch(sn::geom()) { case gSol: return XLAT("Sol"); case gNIH: return XLAT("hyperbolic (3:2)"); case gSolN: return XLAT("Sol (3:2)"); default: return "unknown"; } #else return XLAT("Sol"); #endif case gcNil: return XLAT("Nil"); case gcSL2: return XLAT("~SL(2,R)~"); case gcProduct: return XLAT("%1 x E", PIU(geometry_name())); } return "?"; } EX void select_quotient_screen() { cmode = sm::SIDE | sm::MAYDARK; gamescreen(0); dialog::init(XLAT("quotient spaces in ") + ginf[geometry].tiling_name); char key = 'a'; for(int i=0; i -1)" ) ); dialog::reaction = [] { if(abs(stretch::factor+1) < 1e-3) stretch::factor = -.9; ray::reset_raycaster(); }; } EX void showEuclideanMenu() { // for(int i=2; itest()) set_default_filter(); pushScreen(ge_select_tiling); }); int ts = ginf[geometry].sides; int tv = ginf[geometry].vertex; int nom = (BITRUNCATED ? tv+ts : tv) * 4; int denom = (2*ts + 2*tv - ts * tv); #if CAP_GP if(GOLDBERG || INVERSE) { ld area = PIU(cgi.gpdata->area); if(GOLDBERG || WARPED) { nom = 2 * (2*tv + (S3-2) * ts * (area-1)); } else if(UNRECTIFIED) { if((gp::param.first + gp::param.second) % 2 == 0) nom = ts * 2 * area; else nom = (2*tv + (S3-2) * ts * (area-1)); } else if(UNTRUNCATED) { if((gp::param.first - gp::param.second) % 3 == 0) { nom = ts * 4 * area; denom *= 3; } else { nom = 2 * (2*tv + (S3-2) * ts * (area-1)); denom *= 3; } } } #endif int worldsize; int euler = 0; if(euclid) euler = 0; else if(sphere && nonorientable) euler = 1; else if(sphere) euler = 2; else if(!bounded) euler = -2; else if(WDIM == 3) euler = 0; else switch(geometry) { case gFieldQuotient: worldsize = isize(currentmap->allcells()); euler = 2 * worldsize * denom / nom; break; case gMinimal: euler = -1; break; case gZebraQuotient: case gBolza: euler = -2; break; case gKleinQuartic: case gSchmutzM2: case gBolza2: euler = -4; break; case gSchmutzM3: case gBring: euler = -6; break; case gMacbeath: euler = -12; break; default: worldsize = isize(currentmap->allcells()); println(hlog, "warning: Euler characteristics unknown, worldsize = ", worldsize); euler = 2 * worldsize * denom / nom; break; } nom *= euler; denom *= 2; if(hybri) nom *= hybrid::csteps, denom *= cgi.single_step; int g = gcd(nom, denom); if(g) { nom /= g; denom /= g; } if(euclid && bounded) { worldsize = euc::eu.det; if(BITRUNCATED) worldsize *= (a4 ? 2 : 3); if(GOLDBERG) worldsize *= cgi.gpdata->area; #if CAP_IRR if(IRREGULAR) worldsize *= isize(irr::cells) / isize(irr::cells_of_heptagon); #endif } else worldsize = denom ? nom / denom : 0; if(euler < 0 && !bounded) worldsize = -worldsize; string spf = its(ts); if(0) ; #if CAP_ARCM else if(arcm::in()) { spf = ""; for(int i: arcm::current.faces) { if(spf != "") spf += ","; spf += its(i); } if(BITRUNCATED) spf = "[" + spf + "]," + its(arcm::current.N * 2) + "," + its(arcm::current.N * 2); if(DUAL) spf = its(arcm::current.N) + "^[" + spf + "]"; } #endif #if CAP_BT else if(bt::in()) switch(geometry) { case gBinaryTiling: spf = "6,[6,7],7"; break; case gBinary4: spf = "5,5,5[,5]"; break; case gTernary: spf = "6,6,6[,6]"; break; default: spf = "?"; break; } #endif else if(BITRUNCATED) spf = spf + "," + its(S6) + "," + its(S6); #if CAP_IRR else if(IRREGULAR && irr::bitruncations_performed) spf = "[4..8],6,6"; else if(IRREGULAR) spf = "[4..8]^3"; #endif #if CAP_GP else if(UNRECTIFIED || UNTRUNCATED) { if(UNRECTIFIED && (gp::param.first-gp::param.second) % 2 != 0) spf = "(?)"; else if(UNTRUNCATED && (gp::param.first-gp::param.second) % 3 != 0) spf = "(?)"; else { string each = UNRECTIFIED ? "4" : "3"; int first = UNRECTIFIED ? 4 : 6; int second = S7; if(gp::param == gp::loc(1, 1)) first = second; else if(second < first) swap(first, second); spf = each; for(int z=1; z= 4 if(cgflags & qULTRA) { dialog::addBoolItem(XLAT("truncate ultra-vertices with mirrors"), reg3::ultra_mirror_on, 'Z'); dialog::add_action([] { reg3::ultra_mirror_on = !reg3::ultra_mirror_on; ray::reset_raycaster(); }); } #endif if(prod) { dialog::addSelItem(XLAT("Z-level height factor"), fts(vid.plevel_factor), 'Z'); dialog::add_action([] { dialog::editNumber(vid.plevel_factor, 0, 2, 0.1, 0.7, XLAT("Z-level height factor"), ""); }); } else if(hybri) { dialog::addSelItem(XLAT("number of levels"), its(hybrid::csteps / cgi.single_step), 'L'); dialog::add_action(hybrid::configure_period); } else if(bt::in()) { menuitem_binary_width('v'); add_edit_wall_quality('W'); } else if(nil) { menuitem_nilwidth('v'); } else if(WDIM == 3 || kite::in() || arb::in()) dialog::addBreak(100); else menuitem_change_variation('v'); if(in_s2xe()) { dialog::addSelItem(XLAT("precision of S2xE rings"), its(s2xe::qrings), '5'); dialog::add_action([] { dialog::editNumber(s2xe::qrings, 1, 256, 4, 32, XLAT("precision of S2xE rings"), XLAT( "In S2xE, objects at spherical distances which are multiples of π will look like " "rings, and objects close to these will look like crescents. " "This setting controls the quality of rendering these rings and crescents.") ); dialog::bound_low(1); dialog::bound_up(256); }); } #if MAXMDIM >= 4 if(hybri) { auto r = rots::underlying_scale; dialog::addSelItem(XLAT("view the underlying geometry"), r > 0 ? fts(r)+"x" : ONOFF(false), '6'); dialog::add_action([] { dialog::editNumber(rots::underlying_scale, 0, 1, 0.05, 0.25, XLAT("view the underlying geometry"), XLAT( geometry == gRotSpace ? "The space you are currently in is the space of rotations of the underlying hyperbolic or spherical geometry. " : "You are currently in a product space.") + XLAT( "This option lets you see the underlying space. Lands and some walls (e.g. in the Graveyard) are based on " "the respective features in the underlying world, but details such as monsters or items are ignored." ) ); dialog::bound_low(0); dialog::bound_up(1); dialog::extra_options = [] () { rots::draw_underlying(true); }; }); } #endif if(stretch::applicable()) { dialog::addSelItem(XLAT("stretched geometry"), fts(stretch::factor), 'S'); dialog::add_action(edit_stretch); } dialog::addBreak(100); menuitem_land_structure('l'); if(specialland == laMinefield && bounded) { dialog::addSelItem(XLAT("number of mines"), its(bounded_mine_quantity), 'm'); dialog::add_action([] { dialog::editNumber(bounded_mine_quantity, 0, bounded_mine_max, 1, (bounded_mine_max+5)/10, XLAT("number of mines"), ""); dialog::reaction = [] { if(bounded_mine_quantity < 0) bounded_mine_quantity = 0; if(bounded_mine_quantity > bounded_mine_max) bounded_mine_quantity = bounded_mine_max; }; dialog::reaction_final = [] { bounded_mine_percentage = bounded_mine_quantity * 1. / bounded_mine_max; stop_game(); start_game(); }; }); } if(geometry_has_alt_mine_rule()) { dialog::addSelItem(XLAT("adjacency rule"), XLAT(mine_adjacency_rule ? "vertex" : WDIM == 3 ? "face" : "edge"), 'M'); dialog::add_action([] { stop_game(); mine_adjacency_rule = !mine_adjacency_rule; start_game(); addMessage(XLAT("Note: adjacency rule affects environmental effects, but not movement.")); }); } dialog::addBoolItem(XLAT("pattern"), specialland == laCanvas, 'p'); if(specialland == laCanvas) dialog::lastItem().value = patterns::whichCanvas; dialog::add_action_push(patterns::showPrePattern); validity_info(); if(WDIM == 3) { dialog::addItem(XLAT("3D configuration"), '9'); dialog::add_action_push(show3D); } menuitem_projection('1'); if(nonisotropic && !sl2) dialog::addBoolItem_action(XLAT("geodesic movement in Sol/Nil"), nisot::geodesic_movement, 'G'); #if CAP_CRYSTAL && MAXMDIM >= 4 crystal::add_crystal_transform('x'); #endif dialog::addBreak(50); #if CAP_SHOT dialog::addItem(XLAT("take screenshot"), 's'); dialog::add_action_push(shot::menu); #endif dialog::addHelp(); dialog::addBack(); dialog::addBreak(150); dialog::addTitle(XLAT("info about: %1", full_geometry_name()), 0xFFFFFF, 150); if(WDIM == 2 && !arb::in() && !kite::in()) dialog::addSelItem(XLAT("faces per vertex"), spf, 0); if(arb::in() && arb::current.comment != "") { dialog::addBreak(100); dialog::addHelp(arb::current.comment); } dialog::addSelItem(XLAT("size of the world"), #if CAP_BT bt::in() ? fts(8 * M_PI * sqrt(2) * log(2) / pow(vid.binary_width, WDIM-1), 4) + " exp(∞)" : #endif #if CAP_ARCM arcm::in() && (WDIM == 2) ? arcm::current.world_size() : (arcm::in() && sphere) ? its(isize(currentmap->allcells())) : #endif #if CAP_CRYSTAL cryst ? "∞^" + its(ts/2) : #endif WDIM == 3 && bounded ? its(isize(currentmap->allcells())) : WDIM == 3 && euclid ? "∞" : worldsize < 0 ? (nom%denom ? its(nom)+"/"+its(denom) : its(-worldsize)) + " exp(∞)": (euclid && quotient && !bounded) ? "∞" : worldsize == 0 ? "∞²" : its(worldsize), '3'); if(WDIM == 2 || reg3::in_rule()) dialog::add_action([] { if(!viewdists) { enable_viewdists(); pushScreen(viewdist_configure_dialog); } else if(viewdists) viewdists = false; }); if(bounded) { if(WDIM == 3) euler = 0; dialog::addSelItem(XLAT("Euler characteristics"), its(euler), 0); if(WDIM == 3) ; else if(nonorientable) dialog::addSelItem(XLAT("demigenus"), its(2-euler), 0); else dialog::addSelItem(XLAT("genus"), its((2-euler)/2), 0); } else dialog::addBreak(200); dialog::display(); } EX void runGeometryExperiments() { if(!geometry && specialland == laIce) specialland = getLandForList(cwt.at); pushScreen(showEuclideanMenu); } #if CAP_COMMANDLINE EX eGeometry readGeo(const string& ss) { for(int i=0; i '9') numeric = false; if(numeric) return eGeometry(atoi(ss.c_str())); for(int i=0; i= isize(gxcur.primes)) nextPrime(gxcur); fgeomextras[current_extra].current_prime_id = b; enableFieldChange(); set_geometry(gFieldQuotient); } else if(argis("-triplet")) { stop_game(); shift(); fieldpattern::triplet_id = argi(); fieldpattern::enableFieldChange(); } else if(argis("-to-fq")) { int p = 2; shift(); if(args() == "p") { shift(); p = argi(); shift(); } unsigned hash = arghex(); field_quotient_3d(p, hash); } else if(argis("-cs")) { shift(); cheat(); fieldpattern::matrix M = currfp.strtomatrix(args()); fieldpattern::subpathid = currfp.matcode[M]; fieldpattern::subpathorder = currfp.order(M); } else if(argis("-fwrite")) { shstream hs; hwrite_fpattern(hs, currfp); println(hlog, "current fieldpattern: ", as_cstring(hs.s)); } else if(argis("-csp")) { cheat(); currfp.findsubpath(); } #endif else if(argis("-mineadj")) { shift(); mine_adjacency_rule = argi(); } TOGGLE('7', PURE, set_variation(PURE ? eVariation::bitruncated : eVariation::pure)) else if(argis("-geo")) { PHASEFROM(2); shift(); set_geometry(readGeo(args())); } #if CAP_GP else if(argis("-gp")) { PHASEFROM(2); shift(); gp::param.first = argi(); shift(); gp::param.second = argi(); set_variation(eVariation::goldberg); } else if(argis("-unrectified")) { PHASEFROM(2); set_variation(eVariation::unrectified); } else if(argis("-untruncated")) { PHASEFROM(2); set_variation(eVariation::untruncated); } else if(argis("-warped")) { PHASEFROM(2); set_variation(eVariation::warped); } #endif #if CAP_FIELD else if(argis("-fi")) { fieldpattern::info(); exit(0); } else if(argis("-fi-at")) { geometry = gNormal; shift(); dynamicval s7(S7, argi()); shift(); dynamicval s3(S3, argi()); fieldpattern::info(); exit(0); } else if(argis("-fi-geo")) { fieldpattern::info(); exit(0); } else if(argis("-qs")) { cheat(); shift(); currfp.qpaths.push_back(args()); } #if MAXMDIM >= 4 else if(argis("-truncate-ultra")) { shift(); reg3::ultra_mirror_on = argi(); } #endif else if(argis("-d:quotient")) launch_dialog(showQuotientConfig); #endif else if(argis("-d:geom")) launch_dialog(showEuclideanMenu); else return 1; return 0; } auto ah_geom = addHook(hooks_args, 0, read_geom_args); #endif }