fixed the bug with smart range

Make fake-mobile fail cleanly if font missing.

.github/workflows/build.sh

@@ -0,0 +1,31 @@
+set -x -e o pipefail
+
+
+GH_MYMAKE_ARGS="-fPIC"
+
+HYPERROGUE_USE_GLEW=$GH_HYP_GLEW
+export HYPERROGUE_USE_GLEW=${HYPERROGUE_USE_GLEW: -1}
+
+HYPERROGUE_USE_PNG=$GH_HYP_PNG
+export HYPERROGUE_USE_PNG=${HYPERROGUE_USE_PNG: -1}
+
+HYPERROGUE_USE_ROGUEVIZ=$GH_HYP_RVIZ
+export HYPERROGUE_USE_ROGUEVIZ=${HYPERROGUE_USE_ROGUEVIZ: -1}
+if [[ "$GH_HYP_RVIZ" == "rviz_1" ]]; then
+  GH_MYMAKE_ARGS+=" -std=c++17 -rv"
+fi
+
+export CC=$GH_COMPILER
+export CXX=${CC%cc}++
+export CXXFLAGS_EARLY=-Werror
+
+if [[ "$GH_BUILDSYS" == "makefile" ]]; then
+  make
+elif [[ "$GH_BUILDSYS" == "mymake" ]]; then
+  make mymake
+  ./mymake $GH_MYMAKE_ARGS
+  mv hyper hyperrogue
+else
+  echo 'unknown build system'
+  exit 1
+fi

.github/workflows/github_ci.yml

@@ -0,0 +1,87 @@
+name: Github CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  main_matrix:
+    name: Unix
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # os: [ubuntu-latest, macos-latest]
+        # macos is broken for now
+        os: [ubuntu-latest]
+        compiler: [gcc, clang]
+        build_system: [makefile, mymake]
+        hyper_use_rviz: [rviz_1, rviz_0]
+        hyper_use_png: [png_1]
+        hyper_use_glew: [glew_1]
+    env:
+      GH_OS: ${{ matrix.os }}
+      GH_COMPILER: ${{ matrix.compiler }}
+      GH_BUILDSYS: ${{ matrix.build_system }}
+      GH_HYP_RVIZ: ${{ matrix.hyper_use_rviz }}
+      GH_HYP_PNG: ${{ matrix.hyper_use_png }}
+      GH_HYP_GLEW: ${{ matrix.hyper_use_glew }}
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install build dependencies
+      run: .github/workflows/install_deps.sh
+    - name: Build
+      run: .github/workflows/build.sh
+    - name: Do a simple test
+      run: .github/workflows/test_simple.sh
+
+  windows:
+    name: Windows
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [gcc]
+        build_system: [makefile, mymake]
+        hyper_use_rviz: [rviz_1, rviz_0]
+        hyper_use_png: [png_1]
+        hyper_use_glew: [glew_1]
+    env:
+      GH_OS: windows-latest
+      GH_COMPILER: ${{ matrix.compiler }}
+      GH_BUILDSYS: ${{ matrix.build_system }}
+      GH_HYP_RVIZ: ${{ matrix.hyper_use_rviz }}
+      GH_HYP_PNG: ${{ matrix.hyper_use_png }}
+      GH_HYP_GLEW: ${{ matrix.hyper_use_glew }}
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+    - uses: msys2/setup-msys2@v2
+      with:
+        update: true
+        install: 'pactoys'
+    - uses: actions/checkout@v2
+    - name: Install build dependencies
+      env:
+        MSYSTEM: MSYS
+      run: .github/workflows/install_deps.sh
+    - name: Build
+      run: .github/workflows/build.sh
+    - name: Do a simple test
+      run: .github/workflows/test_simple.sh
+
+# broken for now
+
+#  emscripten:
+#    runs-on: ubuntu-latest
+#    steps:
+#    - uses: actions/checkout@v2
+#    - name: Build
+#     run: |
+#        docker run --rm -v $(pwd):/src trzeci/emscripten make emscripten
+#    - name: Do a simple test
+#      run: |
+#        ls -lAF hyper.html hyper.js hyper.wasm

.github/workflows/install_deps.sh

@@ -0,0 +1,34 @@
+set -x -e o pipefail
+
+
+GH_DEPS_UBUNTU="$GH_COMPILER libsdl1.2-dev libsdl-ttf2.0-dev libsdl-gfx1.2-dev libsdl-mixer1.2-dev"
+GH_DEPS_MACOS="sdl sdl_gfx sdl_mixer sdl_ttf"
+GH_DEPS_MINGW64="$GH_COMPILER:x SDL:x SDL_ttf:x SDL_gfx:x SDL_mixer:x make gdb:x"
+
+if [[ "$GH_HYP_GLEW" == "glew_1" ]]; then
+  GH_DEPS_UBUNTU+=" libglew-dev"
+  GH_DEPS_MACOS+=" glew"
+  GH_DEPS_MINGW64+=" glew:x"
+fi
+
+if [[ "$GH_HYP_PNG" == "png_1" ]]; then
+  GH_DEPS_UBUNTU+=" libpng-dev"
+  GH_DEPS_MACOS+=" libpng"
+  GH_DEPS_MINGW64+=" libpng:x"
+fi
+
+if [[ "$GH_OS" == "ubuntu-latest" ]]; then
+  sudo apt-get -y install $GH_DEPS_UBUNTU
+elif [[ "$GH_OS" == "macos-latest" ]]; then
+  brew update
+  # macos-latest already has both gcc and clang
+  brew install $GH_DEPS_MACOS
+  # work around https://stackoverflow.com/questions/51034399/ for now
+  (cd /usr/local/include && ln -sf SDL/SDL.h)
+elif [[ "$GH_OS" == "windows-latest" ]]; then
+  pacboy -Sy --noconfirm --needed $GH_DEPS_MINGW64
+  sed -i'.orig' 's/<SDL.h>/"SDL.h"/' /mingw64/include/SDL/SDL_gfxPrimitives.h
+else
+  echo 'unknown OS'
+  exit 1
+fi

.github/workflows/test_simple.sh

@@ -0,0 +1,17 @@
+set -x -e o pipefail
+
+
+if [[ "$GH_OS" == "windows-latest" && "$GH_BUILDSYS" == "mymake" ]]; then
+
+cat << ENDOFCMDS > .github/workflows/gdb_cmds.txt
+  run --version
+  backtrace
+  exit 1
+ENDOFCMDS
+
+  echo not running gdb -- not working currently
+  echo gdb --batch -x .github/workflows/gdb_cmds.txt ./hyperrogue
+
+else
+  ./hyperrogue --version
+fi

.gitignore

@@ -1,18 +1 @@
 .deps/
-ChangeLog
-Makefile.in
-aclocal.m4
-autom4te*
-config.guess
-config.sub
-config.log
-config.status
-configure
-depcomp
-Makefile
-install-sh
-missing
-compile
-NEWS
-AUTHORS
-README

.travis.yml

@@ -1,147 +0,0 @@
-language: cpp
-services:
-  - docker
-matrix:
-  include:
-  - os: linux
-    compiler: gcc
-    env: >-
-      TRAVIS_OS_NAME=linux
-      TRAVIS_COMPILER_NAME=gcc
-      TRAVIS_BUILD_SYSTEM=autotools
-      HYPERROGUE_USE_GLEW=1
-      HYPERROGUE_USE_PNG=1
-  - os: osx
-    compiler: clang
-    env: >-
-      TRAVIS_OS_NAME=osx
-      TRAVIS_COMPILER_NAME=clang
-      TRAVIS_BUILD_SYSTEM=autotools
-      HYPERROGUE_USE_GLEW=1
-      HYPERROGUE_USE_PNG=1
-  - os: linux
-    compiler: gcc
-    env: >-
-      TRAVIS_OS_NAME=linux
-      TRAVIS_COMPILER_NAME=gcc
-      TRAVIS_BUILD_SYSTEM=Makefile
-      HYPERROGUE_USE_GLEW=1
-      HYPERROGUE_USE_PNG=1
-      HYPERROGUE_USE_ROGUEVIZ=1
-  - os: linux
-    compiler: clang
-    env: >-
-      TRAVIS_OS_NAME=linux
-      TRAVIS_COMPILER_NAME=clang
-      TRAVIS_BUILD_SYSTEM=Makefile
-      HYPERROGUE_USE_GLEW=1
-      HYPERROGUE_USE_PNG=1
-      HYPERROGUE_USE_ROGUEVIZ=1
-  - os: osx
-    compiler: gcc
-    env: >-
-      TRAVIS_OS_NAME=osx
-      TRAVIS_COMPILER_NAME=gcc
-      TRAVIS_BUILD_SYSTEM=Makefile
-      HYPERROGUE_USE_GLEW=1
-      HYPERROGUE_USE_PNG=1
-      HYPERROGUE_USE_ROGUEVIZ=1
-  - os: osx
-    compiler: clang
-    env: >-
-      TRAVIS_OS_NAME=osx
-      TRAVIS_COMPILER_NAME=clang
-      TRAVIS_BUILD_SYSTEM=Makefile
-      HYPERROGUE_USE_GLEW=1
-      HYPERROGUE_USE_PNG=1
-      HYPERROGUE_USE_ROGUEVIZ=1
-  - os: osx
-    compiler: clang
-    env: >-
-      TRAVIS_OS_NAME=osx
-      TRAVIS_COMPILER_NAME=clang
-      TRAVIS_BUILD_SYSTEM=Makefile
-      HYPERROGUE_USE_GLEW=0
-      HYPERROGUE_USE_PNG=0
-      HYPERROGUE_USE_ROGUEVIZ=0
-  - os: linux
-    env: >-
-      TRAVIS_OS_NAME=linux
-      TRAVIS_COMPILER_NAME=emscripten
-      TRAVIS_BUILD_SYSTEM=emscripten
-
-before_install:
-- |-
-  # Install SDL
-  if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
-    sudo apt-get update -qq
-    sudo apt-get install -qq libsdl1.2-dev libsdl-gfx1.2-dev libsdl-mixer1.2-dev libsdl-ttf2.0-dev
-  elif [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-    brew update
-    brew install sdl sdl_gfx sdl_mixer sdl_ttf
-    # work around https://stackoverflow.com/questions/51034399/ for now
-    (cd /usr/local/include && ln -sf SDL/SDL.h)
-  else
-    exit 'Unsupported OS'
-  fi
-- |-
-  # Install GLEW if asked for
-  if [[ "$HYPERROGUE_USE_GLEW" == "1" ]]; then
-    if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
-      sudo apt-get install -qq libglew-dev
-    elif [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-      brew install glew
-    else
-      exit 'Unsupported OS'
-    fi
-  fi
-- |-
-  # Install libpng if asked for
-  if [[ "$HYPERROGUE_USE_PNG" == "1" ]]; then
-    if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
-      echo 'libpng is installed by default'
-    elif [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-      brew install libpng
-    else
-      exit 'Unsupported OS'
-    fi
-  fi
-- |-
-  # Install autotools if asked for
-  if [[ "$TRAVIS_USE_AUTOTOOLS" == "1" ]]; then
-    if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
-      echo 'autotools is installed by default'
-    elif [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-      brew install automake
-    else
-      exit 'Unsupported OS'
-    fi
-  fi
-
-script:
-- |-
-  # Build hyperrogue.
-  if [[ "$TRAVIS_BUILD_SYSTEM" == "autotools" ]]; then
-    autoreconf -vi
-    ./configure CXXFLAGS="-Wall -Werror"
-    make
-  elif [[ "$TRAVIS_BUILD_SYSTEM" == "Makefile" ]]; then
-    make -f Makefile.simple
-  elif [[ "$TRAVIS_BUILD_SYSTEM" == "emscripten" ]]; then
-    docker run --rm -v $(pwd):/src trzeci/emscripten make -f Makefile.simple emscripten
-  else
-    exit 'Unsupported build system'
-  fi
-- |-
-  # Test hyperrogue.
-  if [[ "$TRAVIS_BUILD_SYSTEM" == "emscripten" ]]; then
-    ls -lAF hyper.html hyper.js hyper.wasm
-  else
-    ./hyperrogue --help
-  fi
-- |-
-  # Test "make dist". ("make distcheck" is expected to fail.)
-  if [[ "$TRAVIS_BUILD_SYSTEM" == "autotools" ]]; then make dist; fi
-- |-
-  # Test "sudo make install".
-  if [[ "$TRAVIS_BUILD_SYSTEM" == "autotools" ]]; then sudo make install; fi

CITATION.cff

@@ -0,0 +1,33 @@
+cff-version: 1.2.0
+message: "If you use RogueViz in your research, please cite it as below. Please also cite the 2017 paper about HyperRogue (see https://archive.bridgesmathart.org/2017/bridges2017-9.html for BibTeX)."
+authors:
+- family-names: "Kopczyński"
+  given-names: "Eryk"
+  orcid: "https://orcid.org/0000-0001-5588-1181"
+- family-names: "Celińska-Kopczyńska"
+  given-names: "Dorota"
+  orcid: "https://orcid.org/0000-0001-5910-0039"
+title: "RogueViz: non-Euclidean geometry engine for visualizations, games, math art, and research"
+type: software
+version: 12.0f
+date-released: 2021-08-05
+url: "https://github.com/zenorogue/hyperrogue/"
+
+references:
+- authors:
+    - family-names: Kopczyński
+      given-names: Eryk
+    - family-names: Celińska
+      given-names: Dorota
+    - family-names: Čtrnáct
+      given-names: Marek
+  title: "HyperRogue: Playing with Hyperbolic Geometry"
+  pages: "9--16"
+  collection-title: "Proceedings of Bridges 2017: Mathematics, Art, Music, Architecture, Education, Culture"
+  year: 2017
+  editor: "Swart, David and S\\'equin, Carlo H. and Fenyvesi, Krist\\'of"
+  isbn: "978-1-938664-22-9"
+  issn: "1099-6702"
+  publisher: "Tessellations Publishing, Phoenix, Arizona"
+  note: "Available online at \\url{http://archive.bridgesmathart.org/2017/bridges2017-9.pdf}" 
+  type: article

Doxyfile

@@ -0,0 +1,283 @@
+DOXYFILE_ENCODING      = UTF-8
+PROJECT_NAME           = "HyperRogue"
+PROJECT_NUMBER         = 11.2
+PROJECT_BRIEF          = "game/visualization engine based on non-Euclidean geometry"
+PROJECT_LOGO           = hr-icon-png96.png
+OUTPUT_DIRECTORY       = doc
+CREATE_SUBDIRS         = NO
+ALLOW_UNICODE_NAMES    = NO
+OUTPUT_LANGUAGE        = English
+OUTPUT_TEXT_DIRECTION  = None
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = YES
+STRIP_FROM_PATH        =
+STRIP_FROM_INC_PATH    =
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = NO
+QT_AUTOBRIEF           = NO
+MULTILINE_CPP_IS_BRIEF = NO
+INHERIT_DOCS           = YES
+SEPARATE_MEMBER_PAGES  = NO
+TAB_SIZE               = 4
+ALIASES                =
+TCL_SUBST              =
+OPTIMIZE_OUTPUT_FOR_C  = NO
+OPTIMIZE_OUTPUT_JAVA   = NO
+OPTIMIZE_FOR_FORTRAN   = NO
+OPTIMIZE_OUTPUT_VHDL   = NO
+OPTIMIZE_OUTPUT_SLICE  = NO
+EXTENSION_MAPPING      =
+MARKDOWN_SUPPORT       = YES
+TOC_INCLUDE_HEADINGS   = 0
+AUTOLINK_SUPPORT       = YES
+BUILTIN_STL_SUPPORT    = NO
+CPP_CLI_SUPPORT        = NO
+SIP_SUPPORT            = NO
+IDL_PROPERTY_SUPPORT   = YES
+DISTRIBUTE_GROUP_DOC   = NO
+GROUP_NESTED_COMPOUNDS = NO
+SUBGROUPING            = YES
+INLINE_GROUPED_CLASSES = NO
+INLINE_SIMPLE_STRUCTS  = NO
+TYPEDEF_HIDES_STRUCT   = NO
+LOOKUP_CACHE_SIZE      = 0
+EXTRACT_ALL            = NO
+EXTRACT_PRIVATE        = NO
+EXTRACT_PACKAGE        = NO
+EXTRACT_STATIC         = NO
+EXTRACT_LOCAL_CLASSES  = YES
+EXTRACT_LOCAL_METHODS  = NO
+EXTRACT_ANON_NSPACES   = NO
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = NO
+CASE_SENSE_NAMES       = YES
+HIDE_SCOPE_NAMES       = NO
+HIDE_COMPOUND_REFERENCE= NO
+SHOW_INCLUDE_FILES     = YES
+SHOW_GROUPED_MEMB_INC  = NO
+FORCE_LOCAL_INCLUDES   = NO
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = NO
+SORT_BRIEF_DOCS        = NO
+SORT_MEMBERS_CTORS_1ST = NO
+SORT_GROUP_NAMES       = NO
+SORT_BY_SCOPE_NAME     = NO
+STRICT_PROTO_MATCHING  = NO
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS       =
+MAX_INITIALIZER_LINES  = 30
+SHOW_USED_FILES        = YES
+SHOW_FILES             = YES
+SHOW_NAMESPACES        = YES
+FILE_VERSION_FILTER    =
+LAYOUT_FILE            =
+CITE_BIB_FILES         =
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_DOC_ERROR      = YES
+WARN_NO_PARAMDOC       = NO
+WARN_AS_ERROR          = NO
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           =
+INPUT                  = 
+USE_MDFILE_AS_MAINPAGE = source-doc.md
+INPUT_ENCODING         = UTF-8
+FILE_PATTERNS          = *.cpp hyper.h classes.h sysconfig.h source-doc.md
+RECURSIVE              = NO
+EXCLUDE                =
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       =
+EXCLUDE_SYMBOLS        =
+EXAMPLE_PATH           =
+EXAMPLE_PATTERNS       = *
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             =
+INPUT_FILTER           =
+FILTER_PATTERNS        =
+FILTER_SOURCE_FILES    = NO
+FILTER_SOURCE_PATTERNS =
+USE_MDFILE_AS_MAINPAGE =
+SOURCE_BROWSER         = NO
+INLINE_SOURCES         = NO
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION    = NO
+REFERENCES_LINK_SOURCE = YES
+SOURCE_TOOLTIPS        = YES
+USE_HTAGS              = NO
+VERBATIM_HEADERS       = NO
+ALPHABETICAL_INDEX     = YES
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          =
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            =
+HTML_FOOTER            =
+HTML_STYLESHEET        =
+HTML_EXTRA_STYLESHEET  =
+HTML_EXTRA_FILES       =
+HTML_COLORSTYLE_HUE    = 220
+HTML_COLORSTYLE_SAT    = 100
+HTML_COLORSTYLE_GAMMA  = 80
+HTML_TIMESTAMP         = NO
+HTML_DYNAMIC_MENUS     = YES
+HTML_DYNAMIC_SECTIONS  = NO
+HTML_INDEX_NUM_ENTRIES = 100
+GENERATE_DOCSET        = NO
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+DOCSET_PUBLISHER_NAME  = Publisher
+GENERATE_HTMLHELP      = NO
+CHM_FILE               =
+HHC_LOCATION           =
+GENERATE_CHI           = NO
+CHM_INDEX_ENCODING     =
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+GENERATE_QHP           = NO
+QCH_FILE               =
+QHP_NAMESPACE          = org.doxygen.Project
+QHP_VIRTUAL_FOLDER     = doc
+QHP_CUST_FILTER_NAME   =
+QHP_CUST_FILTER_ATTRS  =
+QHP_SECT_FILTER_ATTRS  =
+QHG_LOCATION           =
+GENERATE_ECLIPSEHELP   = NO
+ECLIPSE_DOC_ID         = org.doxygen.Project
+DISABLE_INDEX          = NO
+GENERATE_TREEVIEW      = NO
+ENUM_VALUES_PER_LINE   = 4
+TREEVIEW_WIDTH         = 250
+EXT_LINKS_IN_WINDOW    = NO
+FORMULA_FONTSIZE       = 10
+FORMULA_TRANSPARENT    = YES
+USE_MATHJAX            = NO
+MATHJAX_FORMAT         = HTML-CSS
+MATHJAX_RELPATH        = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/
+MATHJAX_EXTENSIONS     =
+MATHJAX_CODEFILE       =
+SEARCHENGINE           = YES
+SERVER_BASED_SEARCH    = NO
+EXTERNAL_SEARCH        = NO
+SEARCHENGINE_URL       =
+SEARCHDATA_FILE        = searchdata.xml
+EXTERNAL_SEARCH_ID     =
+EXTRA_SEARCH_MAPPINGS  =
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         =
+MAKEINDEX_CMD_NAME     = makeindex
+LATEX_MAKEINDEX_CMD    = \makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4
+EXTRA_PACKAGES         =
+LATEX_HEADER           =
+LATEX_FOOTER           =
+LATEX_EXTRA_STYLESHEET =
+LATEX_EXTRA_FILES      =
+PDF_HYPERLINKS         = YES
+USE_PDFLATEX           = YES
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = NO
+LATEX_SOURCE_CODE      = NO
+LATEX_BIB_STYLE        = plain
+LATEX_TIMESTAMP        = NO
+LATEX_EMOJI_DIRECTORY  =
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    =
+RTF_EXTENSIONS_FILE    =
+RTF_SOURCE_CODE        = NO
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_SUBDIR             =
+MAN_LINKS              = NO
+GENERATE_XML           = NO
+XML_OUTPUT             = xml
+XML_PROGRAMLISTING     = YES
+XML_NS_MEMB_FILE_SCOPE = NO
+GENERATE_DOCBOOK       = NO
+DOCBOOK_OUTPUT         = docbook
+DOCBOOK_PROGRAMLISTING = NO
+GENERATE_AUTOGEN_DEF   = NO
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX =
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           =
+INCLUDE_FILE_PATTERNS  =
+PREDEFINED             = HDR=1
+EXPAND_AS_DEFINED      =
+SKIP_FUNCTION_MACROS   = YES
+TAGFILES               =
+GENERATE_TAGFILE       =
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+EXTERNAL_PAGES         = YES
+PERL_PATH              = /usr/bin/perl
+CLASS_DIAGRAMS         = YES
+MSCGEN_PATH            =
+DIA_PATH               =
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = NO
+DOT_NUM_THREADS        = 0
+DOT_FONTNAME           = Helvetica
+DOT_FONTSIZE           = 10
+DOT_FONTPATH           =
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+GROUP_GRAPHS           = YES
+UML_LOOK               = NO
+UML_LIMIT_NUM_FIELDS   = 10
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = NO
+CALLER_GRAPH           = NO
+GRAPHICAL_HIERARCHY    = YES
+DIRECTORY_GRAPH        = YES
+DOT_IMAGE_FORMAT       = png
+INTERACTIVE_SVG        = NO
+DOT_PATH               =
+DOTFILE_DIRS           =
+MSCFILE_DIRS           =
+DIAFILE_DIRS           =
+PLANTUML_JAR_PATH      =
+PLANTUML_CFG_FILE      =
+PLANTUML_INCLUDE_PATH  =
+DOT_GRAPH_MAX_NODES    = 50
+MAX_DOT_GRAPH_DEPTH    = 0
+DOT_TRANSPARENT        = NO
+DOT_MULTI_TARGETS      = NO
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES

FUNDING.yml

@@ -0,0 +1,3 @@
+patreon: zenorogue
+custom: http://www.roguetemple.com/z/donate.php
+github: zenorogue

INSTALL

@@ -1,370 +0,0 @@
-Installation Instructions
-*************************
-
-Copyright (C) 1994-1996, 1999-2002, 2004-2013 Free Software Foundation,
-Inc.
-
-   Copying and distribution of this file, with or without modification,
-are permitted in any medium without royalty provided the copyright
-notice and this notice are preserved.  This file is offered as-is,
-without warranty of any kind.
-
-Basic Installation
-==================
-
-   Briefly, the shell command `./configure && make && make install'
-should configure, build, and install this package.  The following
-more-detailed instructions are generic; see the `README' file for
-instructions specific to this package.  Some packages provide this
-`INSTALL' file but do not implement all of the features documented
-below.  The lack of an optional feature in a given package is not
-necessarily a bug.  More recommendations for GNU packages can be found
-in *note Makefile Conventions: (standards)Makefile Conventions.
-
-   The `configure' shell script attempts to guess correct values for
-various system-dependent variables used during compilation.  It uses
-those values to create a `Makefile' in each directory of the package.
-It may also create one or more `.h' files containing system-dependent
-definitions.  Finally, it creates a shell script `config.status' that
-you can run in the future to recreate the current configuration, and a
-file `config.log' containing compiler output (useful mainly for
-debugging `configure').
-
-   It can also use an optional file (typically called `config.cache'
-and enabled with `--cache-file=config.cache' or simply `-C') that saves
-the results of its tests to speed up reconfiguring.  Caching is
-disabled by default to prevent problems with accidental use of stale
-cache files.
-
-   If you need to do unusual things to compile the package, please try
-to figure out how `configure' could check whether to do them, and mail
-diffs or instructions to the address given in the `README' so they can
-be considered for the next release.  If you are using the cache, and at
-some point `config.cache' contains results you don't want to keep, you
-may remove or edit it.
-
-   The file `configure.ac' (or `configure.in') is used to create
-`configure' by a program called `autoconf'.  You need `configure.ac' if
-you want to change it or regenerate `configure' using a newer version
-of `autoconf'.
-
-   The simplest way to compile this package is:
-
-  1. `cd' to the directory containing the package's source code and type
-     `./configure' to configure the package for your system.
-
-     Running `configure' might take a while.  While running, it prints
-     some messages telling which features it is checking for.
-
-  2. Type `make' to compile the package.
-
-  3. Optionally, type `make check' to run any self-tests that come with
-     the package, generally using the just-built uninstalled binaries.
-
-  4. Type `make install' to install the programs and any data files and
-     documentation.  When installing into a prefix owned by root, it is
-     recommended that the package be configured and built as a regular
-     user, and only the `make install' phase executed with root
-     privileges.
-
-  5. Optionally, type `make installcheck' to repeat any self-tests, but
-     this time using the binaries in their final installed location.
-     This target does not install anything.  Running this target as a
-     regular user, particularly if the prior `make install' required
-     root privileges, verifies that the installation completed
-     correctly.
-
-  6. You can remove the program binaries and object files from the
-     source code directory by typing `make clean'.  To also remove the
-     files that `configure' created (so you can compile the package for
-     a different kind of computer), type `make distclean'.  There is
-     also a `make maintainer-clean' target, but that is intended mainly
-     for the package's developers.  If you use it, you may have to get
-     all sorts of other programs in order to regenerate files that came
-     with the distribution.
-
-  7. Often, you can also type `make uninstall' to remove the installed
-     files again.  In practice, not all packages have tested that
-     uninstallation works correctly, even though it is required by the
-     GNU Coding Standards.
-
-  8. Some packages, particularly those that use Automake, provide `make
-     distcheck', which can by used by developers to test that all other
-     targets like `make install' and `make uninstall' work correctly.
-     This target is generally not run by end users.
-
-Compilers and Options
-=====================
-
-   Some systems require unusual options for compilation or linking that
-the `configure' script does not know about.  Run `./configure --help'
-for details on some of the pertinent environment variables.
-
-   You can give `configure' initial values for configuration parameters
-by setting variables in the command line or in the environment.  Here
-is an example:
-
-     ./configure CC=c99 CFLAGS=-g LIBS=-lposix
-
-   *Note Defining Variables::, for more details.
-
-Compiling For Multiple Architectures
-====================================
-
-   You can compile the package for more than one kind of computer at the
-same time, by placing the object files for each architecture in their
-own directory.  To do this, you can use GNU `make'.  `cd' to the
-directory where you want the object files and executables to go and run
-the `configure' script.  `configure' automatically checks for the
-source code in the directory that `configure' is in and in `..'.  This
-is known as a "VPATH" build.
-
-   With a non-GNU `make', it is safer to compile the package for one
-architecture at a time in the source code directory.  After you have
-installed the package for one architecture, use `make distclean' before
-reconfiguring for another architecture.
-
-   On MacOS X 10.5 and later systems, you can create libraries and
-executables that work on multiple system types--known as "fat" or
-"universal" binaries--by specifying multiple `-arch' options to the
-compiler but only a single `-arch' option to the preprocessor.  Like
-this:
-
-     ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
-                 CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
-                 CPP="gcc -E" CXXCPP="g++ -E"
-
-   This is not guaranteed to produce working output in all cases, you
-may have to build one architecture at a time and combine the results
-using the `lipo' tool if you have problems.
-
-Installation Names
-==================
-
-   By default, `make install' installs the package's commands under
-`/usr/local/bin', include files under `/usr/local/include', etc.  You
-can specify an installation prefix other than `/usr/local' by giving
-`configure' the option `--prefix=PREFIX', where PREFIX must be an
-absolute file name.
-
-   You can specify separate installation prefixes for
-architecture-specific files and architecture-independent files.  If you
-pass the option `--exec-prefix=PREFIX' to `configure', the package uses
-PREFIX as the prefix for installing programs and libraries.
-Documentation and other data files still use the regular prefix.
-
-   In addition, if you use an unusual directory layout you can give
-options like `--bindir=DIR' to specify different values for particular
-kinds of files.  Run `configure --help' for a list of the directories
-you can set and what kinds of files go in them.  In general, the
-default for these options is expressed in terms of `${prefix}', so that
-specifying just `--prefix' will affect all of the other directory
-specifications that were not explicitly provided.
-
-   The most portable way to affect installation locations is to pass the
-correct locations to `configure'; however, many packages provide one or
-both of the following shortcuts of passing variable assignments to the
-`make install' command line to change installation locations without
-having to reconfigure or recompile.
-
-   The first method involves providing an override variable for each
-affected directory.  For example, `make install
-prefix=/alternate/directory' will choose an alternate location for all
-directory configuration variables that were expressed in terms of
-`${prefix}'.  Any directories that were specified during `configure',
-but not in terms of `${prefix}', must each be overridden at install
-time for the entire installation to be relocated.  The approach of
-makefile variable overrides for each directory variable is required by
-the GNU Coding Standards, and ideally causes no recompilation.
-However, some platforms have known limitations with the semantics of
-shared libraries that end up requiring recompilation when using this
-method, particularly noticeable in packages that use GNU Libtool.
-
-   The second method involves providing the `DESTDIR' variable.  For
-example, `make install DESTDIR=/alternate/directory' will prepend
-`/alternate/directory' before all installation names.  The approach of
-`DESTDIR' overrides is not required by the GNU Coding Standards, and
-does not work on platforms that have drive letters.  On the other hand,
-it does better at avoiding recompilation issues, and works well even
-when some directory options were not specified in terms of `${prefix}'
-at `configure' time.
-
-Optional Features
-=================
-
-   If the package supports it, you can cause programs to be installed
-with an extra prefix or suffix on their names by giving `configure' the
-option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
-
-   Some packages pay attention to `--enable-FEATURE' options to
-`configure', where FEATURE indicates an optional part of the package.
-They may also pay attention to `--with-PACKAGE' options, where PACKAGE
-is something like `gnu-as' or `x' (for the X Window System).  The
-`README' should mention any `--enable-' and `--with-' options that the
-package recognizes.
-
-   For packages that use the X Window System, `configure' can usually
-find the X include and library files automatically, but if it doesn't,
-you can use the `configure' options `--x-includes=DIR' and
-`--x-libraries=DIR' to specify their locations.
-
-   Some packages offer the ability to configure how verbose the
-execution of `make' will be.  For these packages, running `./configure
---enable-silent-rules' sets the default to minimal output, which can be
-overridden with `make V=1'; while running `./configure
---disable-silent-rules' sets the default to verbose, which can be
-overridden with `make V=0'.
-
-Particular systems
-==================
-
-   On HP-UX, the default C compiler is not ANSI C compatible.  If GNU
-CC is not installed, it is recommended to use the following options in
-order to use an ANSI C compiler:
-
-     ./configure CC="cc -Ae -D_XOPEN_SOURCE=500"
-
-and if that doesn't work, install pre-built binaries of GCC for HP-UX.
-
-   HP-UX `make' updates targets which have the same time stamps as
-their prerequisites, which makes it generally unusable when shipped
-generated files such as `configure' are involved.  Use GNU `make'
-instead.
-
-   On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot
-parse its `<wchar.h>' header file.  The option `-nodtk' can be used as
-a workaround.  If GNU CC is not installed, it is therefore recommended
-to try
-
-     ./configure CC="cc"
-
-and if that doesn't work, try
-
-     ./configure CC="cc -nodtk"
-
-   On Solaris, don't put `/usr/ucb' early in your `PATH'.  This
-directory contains several dysfunctional programs; working variants of
-these programs are available in `/usr/bin'.  So, if you need `/usr/ucb'
-in your `PATH', put it _after_ `/usr/bin'.
-
-   On Haiku, software installed for all users goes in `/boot/common',
-not `/usr/local'.  It is recommended to use the following options:
-
-     ./configure --prefix=/boot/common
-
-Specifying the System Type
-==========================
-
-   There may be some features `configure' cannot figure out
-automatically, but needs to determine by the type of machine the package
-will run on.  Usually, assuming the package is built to be run on the
-_same_ architectures, `configure' can figure that out, but if it prints
-a message saying it cannot guess the machine type, give it the
-`--build=TYPE' option.  TYPE can either be a short name for the system
-type, such as `sun4', or a canonical name which has the form:
-
-     CPU-COMPANY-SYSTEM
-
-where SYSTEM can have one of these forms:
-
-     OS
-     KERNEL-OS
-
-   See the file `config.sub' for the possible values of each field.  If
-`config.sub' isn't included in this package, then this package doesn't
-need to know the machine type.
-
-   If you are _building_ compiler tools for cross-compiling, you should
-use the option `--target=TYPE' to select the type of system they will
-produce code for.
-
-   If you want to _use_ a cross compiler, that generates code for a
-platform different from the build platform, you should specify the
-"host" platform (i.e., that on which the generated programs will
-eventually be run) with `--host=TYPE'.
-
-Sharing Defaults
-================
-
-   If you want to set default values for `configure' scripts to share,
-you can create a site shell script called `config.site' that gives
-default values for variables like `CC', `cache_file', and `prefix'.
-`configure' looks for `PREFIX/share/config.site' if it exists, then
-`PREFIX/etc/config.site' if it exists.  Or, you can set the
-`CONFIG_SITE' environment variable to the location of the site script.
-A warning: not all `configure' scripts look for a site script.
-
-Defining Variables
-==================
-
-   Variables not defined in a site shell script can be set in the
-environment passed to `configure'.  However, some packages may run
-configure again during the build, and the customized values of these
-variables may be lost.  In order to avoid this problem, you should set
-them in the `configure' command line, using `VAR=value'.  For example:
-
-     ./configure CC=/usr/local2/bin/gcc
-
-causes the specified `gcc' to be used as the C compiler (unless it is
-overridden in the site shell script).
-
-Unfortunately, this technique does not work for `CONFIG_SHELL' due to
-an Autoconf limitation.  Until the limitation is lifted, you can use
-this workaround:
-
-     CONFIG_SHELL=/bin/bash ./configure CONFIG_SHELL=/bin/bash
-
-`configure' Invocation
-======================
-
-   `configure' recognizes the following options to control how it
-operates.
-
-`--help'
-`-h'
-     Print a summary of all of the options to `configure', and exit.
-
-`--help=short'
-`--help=recursive'
-     Print a summary of the options unique to this package's
-     `configure', and exit.  The `short' variant lists options used
-     only in the top level, while the `recursive' variant lists options
-     also present in any nested packages.
-
-`--version'
-`-V'
-     Print the version of Autoconf used to generate the `configure'
-     script, and exit.
-
-`--cache-file=FILE'
-     Enable the cache: use and save the results of the tests in FILE,
-     traditionally `config.cache'.  FILE defaults to `/dev/null' to
-     disable caching.
-
-`--config-cache'
-`-C'
-     Alias for `--cache-file=config.cache'.
-
-`--quiet'
-`--silent'
-`-q'
-     Do not print messages saying which checks are being made.  To
-     suppress all normal output, redirect it to `/dev/null' (any error
-     messages will still be shown).
-
-`--srcdir=DIR'
-     Look for the package's source code in directory DIR.  Usually
-     `configure' can determine that directory automatically.
-
-`--prefix=DIR'
-     Use DIR as the installation prefix.  *note Installation Names::
-     for more details, including other options available for fine-tuning
-     the installation locations.
-
-`--no-create'
-`-n'
-     Run the configure checks, but stop before creating any output
-     files.
-
-`configure' also accepts some other, not widely useful, options.  Run
-`configure --help' for more details.

Makefile

@@ -0,0 +1,196 @@
+# This Makefile works for Mac OS X (El Capitan), MinGW, and Linux.
+# 
+# Environmental vairables:
+#   If you want to build with Glew, set
+#     HYPERROGUE_USE_GLEW=1
+#   If you want to use libpng, set
+#     HYPERROGUE_USE_PNG=1
+#
+# For Mac OS X:
+#   Run `brew install sdl12-compat sdl_gfx sdl_mixer sdl_ttf`
+#   Run `brew install glew libpng` to install the optional dependencies
+#   Run `make` to build HyperRogue as `./hyperrogue`.
+#
+# For MSYS2 and MinGW-w64:
+#   To install SDL and other required libraries, run these commands
+#   from the MSYS2 shell:
+#       pacman -S mingw-w64-ucrt-x86_64-gcc mingw-w64-ucrt-x86_64-glew
+#       pacman -S mingw-w64-ucrt-x86_64-SDL mingw-w64-ucrt-x86_64-SDL_mixer
+#       pacman -S mingw-w64-ucrt-x86_64-SDL_ttf mingw-w64-ucrt-x86_64-SDL_gfx
+#       pacman -S make
+#   Then run "make" to build HyperRogue as ./hyperrogue.exe.
+#
+# For Ubuntu Linux:
+#   Run "sudo apt-get install libsdl-dev" to install SDL in /usr/local.
+#   Run "make" to build HyperRogue as ./hyperrogue.
+
+
+ifeq ($(OS),Windows_NT)
+  OS := mingw
+  TOOLCHAIN := mingw
+else
+  UNAME_S := $(shell uname -s)
+  ifeq ($(UNAME_S),Linux)
+    OS := linux
+  else
+    ifeq ($(UNAME_S),Darwin)
+      OS := osx
+    endif
+  endif
+  TOOLCHAIN_VERSION_S := $(shell $(CXX) --version)
+  ifneq (,$(findstring clang,$(TOOLCHAIN_VERSION_S)))
+    TOOLCHAIN := clang
+  else
+    TOOLCHAIN := gcc
+  endif
+endif
+
+
+## We have now finished inspecting the environment via $(shell).
+## Begin customization points for each OS and TOOLCHAIN we support.
+
+
+ifeq (${OS},linux)
+  CXXFLAGS_EARLY += -DLINUX
+  EXE_EXTENSION :=
+  LDFLAGS_GL := -lGL
+  LDFLAGS_GLEW := -lGLEW
+  LDFLAGS_PNG := -lpng
+  LDFLAGS_SDL := -lSDL -lSDL_gfx -lSDL_mixer -lSDL_ttf -lpthread -lz
+  OBJ_EXTENSION := .o
+  hyper_RES :=
+endif
+
+ifeq (${OS},mingw)
+  CXXFLAGS_EARLY += -DWINDOWS -mwindows -D_A_VOLID=8 -I/ucrt64/include/SDL
+  EXE_EXTENSION := .exe
+  LDFLAGS_GL := -lopengl32
+  LDFLAGS_GLEW := -lglew32
+  LDFLAGS_PNG := -lpng
+  LDFLAGS_SDL := -lSDL -lSDL_gfx -lSDL_mixer -lSDL_ttf -lpthread -lz
+  OBJ_EXTENSION := .o
+  hyper_RES := hyper.res
+  ifeq (${HYPERROGUE_USE_GLEW},)
+    HYPERROGUE_USE_GLEW := 1
+  endif
+endif
+
+ifeq (${OS},osx)
+  HOMEBREW_PREFIX := $(shell brew --prefix)
+  CXXFLAGS_EARLY += -DMAC -I$(HOMEBREW_PREFIX)/include -I$(HOMEBREW_PREFIX)/include/SDL
+  EXE_EXTENSION :=
+  LDFLAGS_EARLY += -L$(HOMEBREW_PREFIX)/lib
+  LDFLAGS_GL := -framework AppKit -framework OpenGL
+  LDFLAGS_GLEW := -lGLEW
+  LDFLAGS_PNG := -lpng
+  LDFLAGS_SDL := -lSDL -lSDLMain -lSDL_gfx -lSDL_mixer -lSDL_ttf -lpthread -lz
+  OBJ_EXTENSION := .o
+  hyper_RES :=
+endif
+
+ifeq (${TOOLCHAIN},clang)
+  CXXFLAGS_STD = -std=c++14
+  CXXFLAGS_EARLY += -fPIC
+  CXXFLAGS_EARLY += -W -Wall -Wextra -Wsuggest-override -pedantic
+  CXXFLAGS_EARLY += -Wno-unused-parameter -Wno-implicit-fallthrough -Wno-maybe-uninitialized -Wno-char-subscripts -Wno-unknown-warning-option
+  CXXFLAGS_EARLY += -Wno-invalid-offsetof
+endif
+
+ifeq (${TOOLCHAIN},gcc)
+  CXXFLAGS_STD = -std=c++14
+  CXXFLAGS_EARLY += -fPIC
+  CXXFLAGS_EARLY += -W -Wall -Wextra -pedantic
+  CXXFLAGS_EARLY += -Wno-unused-parameter -Wno-implicit-fallthrough -Wno-maybe-uninitialized
+  CXXFLAGS_EARLY += -Wno-invalid-offsetof
+endif
+
+ifeq (${TOOLCHAIN},mingw)
+  CXXFLAGS_STD = -std=c++14
+  CXXFLAGS_EARLY += -W -Wall -Wextra
+  CXXFLAGS_EARLY += -Wno-unused-parameter -Wno-implicit-fallthrough -Wno-maybe-uninitialized
+  CXXFLAGS_EARLY += -Wno-invalid-offsetof
+endif
+
+ifeq (${FONTCONFIG},1)
+  CXXFLAGS_EARLY += -DFONTCONFIG `pkg-config --cflags fontconfig`
+  LDFLAGS_EARLY += `pkg-config --libs fontconfig`
+endif
+
+## We have now finished OS-specific and TOOLCHAIN-specific computations.
+## Begin customization points for user-specifiable HYPERROGUE_USE_XXX macros.
+
+
+hyper_OBJS = hyper$(OBJ_EXTENSION)
+hyper_LDFLAGS = $(LDFLAGS_GL) $(LDFLAGS_SDL)
+
+ifeq (${HYPERROGUE_USE_GLEW},1)
+  CXXFLAGS_EARLY += -DCAP_GLEW=1
+  hyper_LDFLAGS += $(LDFLAGS_GLEW)
+else
+  CXXFLAGS_EARLY += -DCAP_GLEW=0
+endif
+
+ifeq (${HYPERROGUE_USE_PNG},1)
+  CXXFLAGS_EARLY += -DCAP_PNG=1
+  hyper_LDFLAGS += $(LDFLAGS_PNG)
+  hyper_OBJS += savepng$(OBJ_EXTENSION)
+else
+  CXXFLAGS_EARLY += -DCAP_PNG=0
+endif
+
+ifeq (${HYPERROGUE_USE_ROGUEVIZ},1)
+  # Enable RogueViz. RogueViz requires C++17.
+  CXXFLAGS_STD = -std=c++17
+  CXXFLAGS_EARLY += -DCAP_ROGUEVIZ=1
+endif
+
+
+## We have now finished HYPERROGUE_USE_XXX-specific computations.
+## Begin the Makefile proper.
+
+
+override CXXFLAGS := $(CXXFLAGS_STD) $(CXXFLAGS_EARLY) $(CXXFLAGS) ${EXTRA_CXXFLAGS}
+override LDFLAGS := $(LDFLAGS_EARLY) $(LDFLAGS) ${EXTRA_LDFLAGS}
+
+hyperrogue$(EXE_EXTENSION): $(hyper_OBJS) $(hyper_RES)
+	$(CXX) $(CXXFLAGS) $(hyper_OBJS) $(hyper_RES) $(LDFLAGS) $(hyper_LDFLAGS) -o $@
+
+hyper$(OBJ_EXTENSION): *.cpp language-data.cpp autohdr.h
+	$(CXX) -O2 $(CXXFLAGS) $(hyper_CXXFLAGS) -c hyper.cpp -o $@
+
+hyper.res: hyper.rc hr-icon.ico
+	windres hyper.rc -O coff -o hyper.res
+
+langen$(EXE_EXTENSION): langen.cpp language-??.cpp language-ptbr.cpp
+	$(CXX) -O0 $(CXXFLAGS) $(langen_CXXFLAGS) langen.cpp $(LDFLAGS) -o $@
+
+makeh$(EXE_EXTENSION): makeh.cpp
+	$(CXX) -O2 makeh.cpp -o $@
+
+autohdr.h: makeh$(EXE_EXTENSION) language-data.cpp *.cpp
+	./makeh classes.cpp locations.cpp colors.cpp hyperpoint.cpp geometry.cpp embeddings.cpp goldberg.cpp init.cpp floorshapes.cpp cell.cpp multi.cpp shmup.cpp pattern2.cpp mapeditor.cpp graph.cpp textures.cpp hprint.cpp language.cpp util.cpp complex.cpp multigame.cpp arbitrile.cpp rulegen.cpp *.cpp > autohdr.h
+
+language-data.cpp: langen$(EXE_EXTENSION)
+	./langen > language-data.cpp
+
+savepng$(OBJ_EXTENSION): savepng.cpp
+	$(CXX) -O2 $(CXXFLAGS) -c savepng.cpp -o $@
+
+mymake$(EXE_EXTENSION): mymake.cpp
+	$(CXX) -O2 $(CXXFLAGS) mymake.cpp -pthread -o $@
+
+emscripten: hyper.html
+
+%.html %.js %.wasm: %.emscripten-sources
+	emcc -std=c++14 -O3 -s USE_ZLIB=1 -s LEGACY_GL_EMULATION=1 -s TOTAL_MEMORY=128MB hyperweb.cpp -o hyper.html
+
+hyper.emscripten-sources: *.cpp autohdr.h
+
+.PHONY: clean
+
+clean:
+	rm -f langen$(EXE_EXTENSION) language-data.cpp
+	rm -f makeh$(EXE_EXTENSION) autohdr.h
+	rm -rf mymake$(EXE_EXTENSION) mymake_files/
+	rm -f hyperrogue$(EXE_EXTENSION) hyper$(OBJ_EXTENSION) $(hyper_RES) savepng$(OBJ_EXTENSION)
+	rm -f hyper.html hyper.js hyper.wasm

Makefile.am

@@ -1,46 +0,0 @@
-bin_PROGRAMS = hyperrogue
-hyperroguedir = $(datadir)/hyperrogue
-hyperrogue_SOURCES = hyper.cpp savepng.cpp
-hyperrogue_CPPFLAGS = -DFONTDESTDIR=\"$(pkgdatadir)/DejaVuSans-Bold.ttf\" -DMUSICDESTDIR=\"$(pkgdatadir)/hyperrogue-music.txt\" -DSOUNDDESTDIR=\"$(pkgdatadir)/sounds/\"
-hyperrogue_CXXFLAGS = -O2 -std=c++11 ${AM_CXXFLAGS}
-dist_hyperrogue_DATA = hyperrogue-music.txt DejaVuSans-Bold.ttf
-
-# docdir
-dist_doc_DATA = README.md
-
-# musicdir
-musicdir=$(datadir)/hyperrogue/music
-dist_music_DATA = music/hr3-caves.ogg music/hr3-desert.ogg music/hr3-hell.ogg music/hr3-jungle.ogg music/hr3-mirror.ogg music/hr3-rlyeh.ogg music/hr3-crossroads.ogg music/hr3-graveyard.ogg music/hr3-icyland.ogg music/hr3-laboratory.ogg music/hr3-motion.ogg
-
-# soundsdir
-soundsdir=$(datadir)/hyperrogue/sounds
-dist_sounds_DATA = sounds/*
-
-noinst_PROGRAMS = langen
-langen_SOURCES = langen.cpp 
-langen_CXXFLAGS = -O0 -std=c++11 ${AM_CXXFLAGS}
-BUILT_SOURCES = language-data.cpp
-
-language-data.cpp: langen
-	./langen > language-data.cpp
-
-#############################
-# Platform specific setup
-#############################
-
-if MAC
-hyperrogue_LDFLAGS = -lSDLmain -framework AppKit -framework OpenGL
-endif MAC
-
-if MINGW
-nodist_hyperrogue_SOURCES = hyper.res
-hyperrogue_CPPFLAGS += -march=native -DWINDOWS
-windres_prefix = ${host_cpu}-w64-mingw32-
-endif MINGW
-
-#############################
-# Arch specific setup
-#############################
-
-hyper.res: hyper.rc hr-icon.ico
-	${windres_prefix}windres hyper.rc -O coff -o hyper.res

Makefile.rv

@@ -63,7 +63,7 @@ savepng-loc.o: savepng.cpp
 hyper-rogueviz.o: hyper.cpp graph.cpp hyperpoint.cpp geometry.cpp cell.cpp heptagon.cpp game.cpp classes.cpp polygons.cpp language.cpp language-data.cpp achievement.cpp shmup.cpp patterns.cpp mapeditor.cpp netgen.cpp yendor.cpp hyper.h rug.cpp flags.cpp system.cpp landgen.cpp orbs.cpp complex.cpp conformal.cpp menus.cpp init.cpp dialogs.cpp sound.cpp util.cpp ${drogueviz} fieldpattern.cpp ${MAIN} control.cpp commandline.cpp
 	${CXX} ${PROF} ${MAIN} -c -o hyper-rogueviz.o ${MYFLAGS}
 
-langen: langen.cpp language-cz.cpp language-pl.cpp language-tr.cpp language-ru.cpp language-de.cpp
+langen: langen.cpp language-cz.cpp language-pl.cpp language-tr.cpp language-ru.cpp language-de.cpp language-ptbr.cpp language-fr.cpp
 	${CXX} langen.cpp -o langen -g
 
 language-data.cpp: langen
@@ -191,6 +191,9 @@ treeoflife-white: hyper
 collatz: hyper
 	${CMD} -canvas h -dftcolor 206020FF -ggamma 2 -collatz .3,.5,-.4,.4
 
+collatz-bird: hyper
+	${CMD} -canvas h -dftcolor R -ggamma 2 -geo 435h -collatz3 txy .3 fd .25 tyz pi/2 / txy -.4 fd .2 tyz pi/2 -PM 0 -rvshape 3 -I Flash 100 -I Speed 100
+
 fullnet: hyper
 	${CMD} -dftcolor 808080FF -ggamma 2 -back FFFFFF -net
 

Makefile.simple

@@ -1,165 +0,0 @@
-# This Makefile works for Mac OS X (El Capitan), MinGW, and Linux.
-#
-# For Mac OS X:
-#   Run "brew install sdl" to install SDL in /usr/local.
-#   Run "brew install sdl_gfx".
-#   Run "brew install sdl_mixer".
-#   Run "brew install sdl_ttf".
-#   Run "make -f Makefile.simple" to build HyperRogue as ./hyperrogue.
-#
-# For MSYS2 and MinGW-w64:
-#   You might need to run commands such as "pacman -S mingw-w64-x86_64-SDL"
-#   to install SDL and other required libraries.
-#   Run "make -f Makefile.simple" to build HyperRogue as ./hyperrogue.exe.
-#
-# For Ubuntu Linux:
-#   Run "sudo apt-get install libsdl-dev" to install SDL in /usr/local.
-#   Run "make -f Makefile.simple" to build HyperRogue as ./hyperrogue.
-
-
-ifeq ($(OS),Windows_NT)
-  OS := mingw
-  TOOLCHAIN := mingw
-else
-  UNAME_S := $(shell uname -s)
-  ifeq ($(UNAME_S),Linux)
-    OS := linux
-  else
-    ifeq ($(UNAME_S),Darwin)
-      OS := osx
-    endif
-  endif
-  TOOLCHAIN_VERSION_S := $(shell $(CXX) --version)
-  ifneq (,$(findstring clang,$(TOOLCHAIN_VERSION_S)))
-    TOOLCHAIN := clang
-  else
-    TOOLCHAIN := gcc
-  endif
-endif
-
-
-## We have now finished inspecting the environment via $(shell).
-## Begin customization points for each OS and TOOLCHAIN we support.
-
-
-ifeq (${OS},linux)
-  CXXFLAGS_EARLY += -DLINUX
-  EXE_EXTENSION :=
-  LDFLAGS_GL := -lGL
-  LDFLAGS_GLEW := -lGLEW
-  LDFLAGS_PNG := -lpng
-  LDFLAGS_SDL := -lSDL -lSDL_gfx -lSDL_mixer -lSDL_ttf
-  OBJ_EXTENSION := .o
-  hyper_RES :=
-endif
-
-ifeq (${OS},mingw)
-  CXXFLAGS_EARLY += -DWINDOWS -mwindows -D_A_VOLID=8
-  EXE_EXTENSION := .exe
-  LDFLAGS_GL := -lopengl32
-  LDFLAGS_GLEW := -lglew32
-  LDFLAGS_PNG := -lpng
-  LDFLAGS_SDL := -lSDL -lSDL_gfx -lSDL_mixer -lSDL_ttf
-  OBJ_EXTENSION := .o
-  hyper_RES := hyper.res
-  ifeq (${HYPERROGUE_USE_GLEW},)
-    HYPERROGUE_USE_GLEW := 1
-  endif
-endif
-
-ifeq (${OS},osx)
-  CXXFLAGS_EARLY += -DMAC -I/usr/local/include
-  EXE_EXTENSION :=
-  LDFLAGS_EARLY += -L/usr/local/lib
-  LDFLAGS_GL := -framework AppKit -framework OpenGL
-  LDFLAGS_GLEW := -lGLEW
-  LDFLAGS_PNG := -lpng
-  LDFLAGS_SDL := -lSDL -lSDLMain -lSDL_gfx -lSDL_mixer -lSDL_ttf
-  OBJ_EXTENSION := .o
-  hyper_RES :=
-endif
-
-ifeq (${TOOLCHAIN},clang)
-  CXXFLAGS_EARLY += -std=c++11 -march=native
-  CXXFLAGS_EARLY += -W -Wall -Wextra -Werror -pedantic
-  CXXFLAGS_EARLY += -Wno-format-pedantic -Wno-missing-field-initializers -Wno-unused-parameter
-endif
-
-ifeq (${TOOLCHAIN},gcc)
-  CXXFLAGS_EARLY += -std=c++11 -march=native
-  CXXFLAGS_EARLY += -W -Wall -Wextra -Werror
-  CXXFLAGS_EARLY += -Wno-maybe-uninitialized -Wno-missing-field-initializers -Wno-unused-parameter
-endif
-
-ifeq (${TOOLCHAIN},mingw)
-  CXXFLAGS_EARLY += -std=c++11 -march=native
-  CXXFLAGS_EARLY += -W -Wall -Wextra -Werror
-  CXXFLAGS_EARLY += -Wno-unused-parameter
-endif
-
-
-## We have now finished OS-specific and TOOLCHAIN-specific computations.
-## Begin customization points for user-specifiable HYPERROGUE_USE_XXX macros.
-
-
-hyper_OBJS = hyper$(OBJ_EXTENSION)
-hyper_LDFLAGS = $(LDFLAGS_GL) $(LDFLAGS_SDL)
-
-ifeq (${HYPERROGUE_USE_GLEW},1)
-  CXXFLAGS_EARLY += -DCAP_GLEW=1
-  hyper_LDFLAGS += $(LDFLAGS_GLEW)
-else
-  CXXFLAGS_EARLY += -DCAP_GLEW=0
-endif
-
-ifeq (${HYPERROGUE_USE_PNG},1)
-  CXXFLAGS_EARLY += -DCAP_PNG=1
-  hyper_LDFLAGS += $(LDFLAGS_PNG)
-  hyper_OBJS += savepng$(OBJ_EXTENSION)
-else
-  CXXFLAGS_EARLY += -DCAP_PNG=0
-endif
-
-ifeq (${HYPERROGUE_USE_ROGUEVIZ},1)
-  # Enable RogueViz.
-  CXXFLAGS_EARLY += -DCAP_ROGUEVIZ=1
-endif
-
-
-## We have now finished HYPERROGUE_USE_XXX-specific computations.
-## Begin the Makefile proper.
-
-
-override CXXFLAGS := $(CXXFLAGS_EARLY) $(CXXFLAGS) ${EXTRA_CXXFLAGS}
-override LDFLAGS := $(LDFLAGS_EARLY) $(LDFLAGS) ${EXTRA_LDFLAGS}
-
-hyperrogue$(EXE_EXTENSION): $(hyper_OBJS) $(hyper_RES)
-	$(CXX) $(CXXFLAGS) $(hyper_OBJS) $(hyper_RES) $(LDFLAGS) $(hyper_LDFLAGS) -o $@
-
-hyper$(OBJ_EXTENSION): *.cpp language-data.cpp
-	$(CXX) -O2 $(CXXFLAGS) $(hyper_CXXFLAGS) -c hyper.cpp -o $@
-
-hyper.res: hyper.rc hr-icon.ico
-	windres hyper.rc -O coff -o hyper.res
-
-langen$(EXE_EXTENSION): langen.cpp language-??.cpp language-ptbr.cpp
-	$(CXX) -O0 $(CXXFLAGS) $(langen_CXXFLAGS) langen.cpp $(LDFLAGS) -o $@
-
-language-data.cpp: langen$(EXE_EXTENSION)
-	./langen > language-data.cpp
-
-savepng$(OBJ_EXTENSION): savepng.cpp
-	$(CXX) -O2 $(CXXFLAGS) -c savepng.cpp -o $@
-
-emscripten: hyper.html
-
-%.html %.js %.wasm: %.emscripten-sources
-	emcc -std=c++11 -O3 -s LEGACY_GL_EMULATION=1 -s TOTAL_MEMORY=128*1024*1024 hyperweb.cpp -o hyper.html
-
-hyper.emscripten-sources: *.cpp
-
-.PHONY: clean
-
-clean:
-	rm -f hyperrogue$(EXE_EXTENSION) hyper$(OBJ_EXTENSION) $(hyper_RES) langen$(EXE_EXTENSION) language-data.cpp savepng$(OBJ_EXTENSION)
-	rm -f hyper.html hyper.js hyper.wasm

README.md

@@ -1,20 +1,11 @@
 # HyperRogue
-<p align="right">
-<a href="https://travis-ci.org/zenorogue/hyperrogue/builds">
-<img align="right" src="https://badges.herokuapp.com/travis/zenorogue/hyperrogue?branch=master&env=TRAVIS_BUILD_SYSTEM=autotools&label=autotools" alt="TravisCI badge">
-<img align="right" src="https://badges.herokuapp.com/travis/zenorogue/hyperrogue?branch=master&env=TRAVIS_BUILD_SYSTEM=Makefile&label=make" alt="TravisCI badge">
-<img align="right" src="https://badges.herokuapp.com/travis/zenorogue/hyperrogue?branch=master&env=TRAVIS_BUILD_SYSTEM=emscripten&label=web" alt="TravisCI badge">
-</a>
-</p>
-<p align="left">
-<b>Current version: 11.0a</b>
-</p>
 
 A puzzle roguelike in the hyperbolic plane. See the [HyperRogue website](http://roguetemple.com/z/hyper.php) for detailed and most up-to-date information.
+Compiled executables can be downloaded from [itch.io](https://zenorogue.itch.io/hyperrogue) and from the [HyperRogue website](http://www.roguetemple.com/z/hyper/download.php).
 
-Released under [GNU General Public License, version 2](http://www.gnu.org/licenses/gpl-2.0.html). As such, it comes with without any warranty.
+Released under [GNU General Public License, version 2](http://www.gnu.org/licenses/gpl-2.0.html). As such, it comes without any warranty.
 
-If you would like to thank me for HyperRogue, you can support the development by buying paid versions (with more up-to-date content and some social features), or [in other ways](http://www.roguetemple.com/z/donate.php?id=NotEye). 
+If you would like to thank me for HyperRogue, you can support the development by buying paid versions (with more up-to-date content and some social and competitive features), or [in other ways](http://www.roguetemple.com/z/donate.php?id=hyper). 
 You can contact me at zeno@attnam.com, or at [my blog](http://zenorogue.blogspot.com/), or via [Twitter](https://twitter.com/ZenoRogue).
 
 ## The game ##
@@ -28,7 +19,7 @@ Ultimately, you will probably run into a situation where monsters surround you.
 
 Collecting enough treasure also allows you to find rare magical orbs, which grant you one-time or time-limited special abilities.
 
-The world is a combination of thirteen types of lands. Each land type has specific style (monsters, treasure, magical orbs, terrain features). Collecting treasures only attracts more monsters in lands of the same type, so you can try to collect lots of treasure in several different lands!
+The world is a combination of over 60 types of lands. Each land type has specific style (monsters, treasure, magical orbs, terrain features). Collecting treasures only attracts more monsters in lands of the same type, so you can try to collect lots of treasure in several different lands!
 
 Some of these lands are available from the beginning, others can be found only if you have proven yourself (press ESC to know what you should do to access more lands). Ultimately, you will be able to access Hell, and look for the fabulous Orbs of Yendor which are hidden there. Get at least one of them to prove that you are a true winner! Only the best players will be able to face the challenges of Hell, but both the monsters and the challenges associated with the Orbs of Yendor are different than in the rest of the game, so it should be worth it.
 
@@ -36,31 +27,53 @@ You can see tooltips by placing the mouse over stuff. You can also right click t
 
 Press v to configure the game. You can also rotate the world by pressing arrow keys, PageUp and PageDn (not numpad). You can center on the PC by pressing Home.
 
-Your scores and other stats about your games are recorded to file hyperrogue.log (in Linux, *~/.hyperrogue.log*). You can save your configation to file hyperrogue.ini (in Linux, *~/.hyperrogue.ini*).
+Your scores and other stats about your games are recorded to file hyperrogue.log (in Linux, *~/.hyperrogue.log*). You can save your configuration to file hyperrogue.ini (in Linux, *~/.hyperrogue.ini*).
 
-The surface the game is played on is called a hyperbolic plane. It seems there is just a very small amount of games and other works of art which use hyperbolic geometry (the most well known are some works of M.C.Escher).
+The surface the game is played on is called a hyperbolic plane. It seems there is just a very small amount of games and other works of art which use hyperbolic geometry (the most well known are some works of M.C.  Escher).
 
 The game dynamically generates new parts of the world as you move. Due to nature of the hyperbolic plane, the chances that you get back to a place where you have been before are very low (unless you go back exactly the same way). See more information about the geometry used [on the blog](http://zenorogue.blogspot.com/2012/03/hyperbolic-geometry-in-hyperbolic-rogue.html).
 
-You can aim for the Orb of Yendor, or you can simply aim for as high score as possible. My best so far is $175 but it should be beatable (I mean, I have won fairly only once, and that was my end score in the winning game).
+You can aim for the Orb of Yendor, or you can simply aim for as high score as possible.
 
-## Technical information ##
+## Modifications
 
-You should be able to compile on Ubuntu (or similar) with something like this (you need SDL, SDL_ttf, and SDL_gfx):
+OK, now lots of the above can be changed. You can change the geometry and topology (to Euclidean, spherical, or even to nonisotropic 3D geometries). You can play challenges based on
+various in-game quests, and even try some other game genres in non-Euclidean spaces (roguelite aka shmup, racing, peaceful puzzles).
 
+## RogueViz
+
+HyperRogue uses [RogueViz](http://roguetemple.com/z/hyper/rogueviz.php), which is our engine for non-Euclidean games, computations and visualizations. This repo includes the source code of RogueViz demos in subdirectory `rogueviz`, but
+not the data, which is available on [itch.io](https://zenorogue.itch.io/rogueviz). RogueViz is funded by the National Science Centre, Poland, grant UMO-2019/35/B/ST6/04456.
+
+## Development ##
+
+### Build prerequisites ###
+
+On Linux with apt-get:
+
+```sudo apt-get install make g++ libsdl1.2-dev libsdl-ttf2.0-dev libsdl-gfx1.2-dev libsdl-mixer1.2-dev libglew-dev```
+
+On macOS with Homebrew:
+
+```brew install sdl sdl_ttf sdl_gfx sdl_mixer glew libpng```
+
+### Building HyperRogue from source ###
 ```
-sudo apt-get install gcc libsdl1.2-dev libsdl-ttf2.0-dev libsdl-gfx1.2-dev
 git clone https://github.com/zenorogue/hyperrogue.git hyperrogue
 cd hyperrogue
-autoreconf -vi
-./configure
-make
+HYPERROGUE_USE_GLEW=1 HYPERROGUE_USE_PNG=1 make
 ```
 
-There is also a standalone Makefile for Linux, OSX, and MinGW.
+The `mymake` program builds HyperRogue in parts. It takes longer than the method shown above, but it uses significantly less memory during compilation, and when you change something, `mymake` will only recompile the changed file.
+Additionally, it can be easily configured, e.g., to produce an optimized build, or to include addons (see `mymake.cpp` for some example invocations, and `devmods` for some example addons).
+Most useful parameters include `-O3` (optimized build), `-rv` (include the RogueViz demos), `-vr` (build the VR version). Compiler flags like `-Werror` (treat warnings as errors) and `-march=native` work too.
+
 
 ```
-git clone https://github.com/zenorogue/hyperrogue.git
-cd hyperrogue
-make -f Makefile.simple
+make mymake && ./mymake
 ```
+
+The source code is not documented very well. You can see the current state of the documentation, as generated by Doxygen, [here](https://zenorogue.github.io/hyperrogue-doc/).
+
+## Discussion ##
+The best place to discuss HyperRogue is our [Discord server|https://discord.com/invite/8G44XkR].

achievement.cpp

@@ -1,17 +1,28 @@
-// Hyperbolic Rogue -- achievements
-// Copyright (C) 2011-2018 Zeno Rogue, see 'hyper.cpp' for details
+// Hyperbolic Rogue -- Achievements
+// Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details
 
+/** \file achievements.cpp 
+ *  \brief This file implements routines related to achievements and leaderboards
+ *
+ *  This routines are general, i.e., not necessarily Steam-specific.
+ */
+
+#include "hyper.h"
 namespace hr {
 
-#define NUMLEADER 78
+#if HDR
+#define NUMLEADER 90
+#endif
 
-bool offlineMode = false;
+EX bool test_achievements = false;
 
-const char* leadernames[NUMLEADER] = {
+EX bool offlineMode = false;
+
+EX const char* leadernames[NUMLEADER] = {
   "Score", "Diamonds", "Gold", "Spice", "Rubies", "Elixirs",
   "Shards100", "Totems", "Daisies", "Statues", "Feathers", "Sapphires",
   "Hyperstones", "Time to Win-71", "Turns to Win-71",
-  "Time to 10 Hyperstones-103", "Turns to 10 Hyperstones-103", "Orbs of Yendor",
+  "Time to 10 Hyperstones-120", "Turns to 10 Hyperstones-120", "Orbs of Yendor",
   "Fern Flowers", 
   "Royal Jellies", "Powerstones", "Silver", "Wine", "Emeralds", "Grimoires",
   "Holy Grails", "Red Gems", "Pirate Treasures",
@@ -62,28 +73,77 @@ const char* leadernames[NUMLEADER] = {
   "Lava Lilies", // 74
   "Turquoises", // 75
   "Chrysoberyls", // 76
-  "Tasty Jellies" // 77
+  "Tasty Jellies", // 77
+  "Tiger's Eyes", // 78
+  "Torbernites", // 79
+  "Meteorites", // 80
+  "Racing Official Track", // 81
+  "Gold Balls", // 82
+  "Lazurite Figurines", // 83
+  "Water Lilies", // 84
+  "Capon Stones", // 85
+  "Crystal Dice", // 86
+  "Crossbow (bull)", // 87
+  "Crossbow (geodesic)", // 88
+  "Crossbow (geometric)", // 89
   };
 
+#if HDR
+#define LB_PRINCESS 36
 #define LB_STATISTICS 62
-#define LB_HALLOWEEN  63
+#define LB_HALLOWEEN 63
+#define LB_YENDOR_CHALLENGE 40
+#define LB_PURE_TACTICS 41
+#define LB_PURE_TACTICS_SHMUP 49
+#define LB_PURE_TACTICS_COOP 50
+#define LB_RACING 81
+#endif
 
-void upload_score(int id, int v);
+EX void achievement_init();
+EX string myname();
+EX void achievement_close();
+EX void achievement_pump();
 
-string achievementMessage[3];
-int achievementTimer;
-vector<string> achievementsReceived;
+/** gain the given achievement.
+ * @param s name of the achievement, e.g., DIAMOND1
+ * @param flags one of the constants from namespace rg. The achievement is only awarded if special modes are matched exactly.
+ */
+EX void achievement_gain(const char* s, char flags IS(0));
 
-bool wrongMode(char flags) {
+EX bool haveLeaderboard(int id);
+EX int get_currentscore(int id);
+EX void set_priority_board(int id);
+EX int get_sync_status();
+EX bool score_loaded(int id);
+EX int score_default(int id);
+EX void improveItemScores();
+EX void upload_score(int id, int v);
+
+EX string achievementMessage[3];
+EX int achievementTimer;
+/** achievements received this game */
+EX vector<string> achievementsReceived;
+
+/** Returns true if the given achievement cannot be obtained in the current mode.
+ *  @param flags Mode requested by the achievement. 
+ */
+EX bool wrongMode(char flags) {
   if(cheater) return true;
+  if(casual) return true;
   if(flags == rg::global) return false;
+  if(flags == rg::fail) return true;
 
-  if(flags != rg::special_geometry) {
+  if(flags != rg::special_geometry && flags != rg::special_geometry_nicewalls) {
     if(!BITRUNCATED) return true;
     if(geometry != gNormal) return true;
+    if(disksize) return true;
     }
+  if(ineligible_starting_land && !flags) return true;
+  if(use_custom_land_list) return true;
 
-  if(shmup::on != (flags == rg::shmup)) return true;
+  if(shmup::on != (flags == rg::shmup || flags == rg::racing)) return true;
+  if(racing::on != (flags == rg::racing)) return true;
+  if((!!dual::state) != (flags == rg::dualmode)) return true;
 #if CAP_DAILY
   if(daily::on != (flags == rg::daily)) return true;
 #endif
@@ -94,18 +154,68 @@ bool wrongMode(char flags) {
 #if CAP_TOUR
   if(tour::on) return true;
 #endif
-  if(chaosmode != (flags == rg::chaos)) return true;
+  eLandStructure dls = lsNiceWalls;
+  if(flags == rg::princess && !princess::challenge) return true;
+  if(flags == rg::special_geometry || flags == rg::princess)
+    dls = lsSingle;
+  if(flags == rg::chaos)
+    dls = lsChaos;
+  /* in the official racing achievements, the tracks are saved maps anyway */
+  if(flags == rg::racing)
+    dls = land_structure;
+
+  if(land_structure != dls) return true;
+  if(shmup::on && vid.creature_scale != 1) return true;
+  if(numplayers() > 1 && !multi::friendly_fire) return true;
+  if(numplayers() > 1 && multi::pvp_mode) return true;
+  if(numplayers() > 1 && multi::split_screen) return true;
   if((numplayers() > 1) != (flags == rg::multi)) return true;
   return false;
   }
 
-void achievement_log(const char* s, char flags) {
+EX set<string> got_achievements;
 
-#ifdef PRINT_ACHIEVEMENTS
-  printf("achievement = %s [%d]\n", s, wrongMode(flags));
-#endif
-  
-  if(wrongMode(flags)) return;
+EX void achievement_gain_once(const string& s, char flags IS(0)) {
+  LATE(achievement_gain_once(s, flags));
+  if(got_achievements.count(s)) return;
+  if(wrongMode(flags)) {
+    if(test_achievements) println(hlog, "wrong mode for achievement: ", s);
+    else return;
+    }
+  got_achievements.insert(s);
+  achievement_gain(s.c_str(), flags);
+  }
+
+namespace rg {
+  char check(bool b, char val = special_geometry) { return b ? val : fail; }
+  }
+
+EX char specgeom_zebra() { return rg::check(geometry == gZebraQuotient && !disksize && BITRUNCATED && firstland == laDesert); }
+EX char specgeom_lovasz() { return rg::check(geometry == gKleinQuartic && variation == eVariation::untruncated && gp::param == gp::loc(1,1) && !disksize && in_lovasz()); }
+EX char specgeom_halloween() { return rg::check((geometry == gSphere || geometry == gElliptic) && BITRUNCATED && !disksize && firstland == laHalloween); }
+EX char specgeom_heptagonal() { return rg::check(PURE && geometry == gNormal && !disksize, rg::special_geometry_nicewalls); }
+EX char specgeom_euclid_gen() { return rg::check(geometry == gEuclid && !disksize && firstland == laMirrorOld); }
+EX char specgeom_crystal1() { return rg::check(PURE && cryst && ginf[gCrystal].sides == 8 && ginf[gCrystal].vertex == 4 && !crystal::used_compass_inside && !disksize && firstland == laCamelot); }
+EX char specgeom_crystal2() { return rg::check(BITRUNCATED && cryst && ginf[gCrystal].sides == 8 && ginf[gCrystal].vertex == 3 && !crystal::used_compass_inside && !disksize && firstland == laCamelot); }
+
+EX vector<std::function<char()>> all_specgeom_checks = { specgeom_zebra, specgeom_lovasz, specgeom_halloween, specgeom_heptagonal, specgeom_crystal1, specgeom_crystal2, specgeom_euclid_gen };
+
+EX char any_specgeom() {
+  for(auto chk: all_specgeom_checks) if(chk() != rg::fail) return chk();
+  return rg::fail;
+  }
+
+EX void achievement_log(const char* s, char flags) {
+
+  if(wrongMode(flags)) {
+    if(test_achievements) println(hlog, "wrong mode for achievement: ", s);
+    return;
+    }
+
+  if(test_achievements) {
+    println(hlog, "got achievement:", s);
+    return;
+    }
   
   for(int i=0; i<isize(achievementsReceived); i++)
     if(achievementsReceived[i] == s) return;
@@ -114,7 +224,7 @@ void achievement_log(const char* s, char flags) {
 #if CAP_SAVE
   remove_emergency_save();
 
-  FILE *f = fopen(scorefile, "at");
+  FILE *f = fopen(scorefile.c_str(), "at");
   if(!f) return;
   
   int t = (int) (time(NULL) - timerstart);
@@ -129,27 +239,42 @@ void achievement_log(const char* s, char flags) {
 #endif
   }
 
-#if ISSTEAM
-void improveItemScores();
-#include "private/hypersteam.cpp"
-#elif !ISANDROID && !ISIOS
+#ifndef LEADER
+#define LEADER "Unknown"
+#define LEADERFULL "Unknown"
+#endif
+
+#if !CAP_ACHIEVE
 void achievement_init() {}
+string myname() { return "Rogue"; }
 void achievement_close() {}
+// gain the achievement with the given name.
+// flags: 'e' - for Euclidean, 's' - for Shmup, '7' - for heptagonal
+// Only awarded if special modes are matched exactly.
 void achievement_gain(const char* s, char flags) {
   achievement_log(s, flags);
   }
+void achievement_pump() {}
+EX int get_sync_status() { return 0; }
+EX void set_priority_board(int) { }
 #endif
 
-void achievement_collection(eItem it, int prevgold, int newgold) {
-  if(cheater) return;
-  if(randomPatternsMode) return;
-  int q = items[it];
-  
-  if(it == itTreat && q == 50 && (geometry == gSphere || geometry == gElliptic) && BITRUNCATED) 
-    achievement_gain("HALLOWEEN1", rg::special_geometry);
+// gain the achievement for collecting a number of 'it'.
+EX void achievement_collection(eItem it) {
+  achievement_collection2(it, items[it]);
+  }
 
-  if(it == itTreat && q == 100 && (geometry == gSphere || geometry == gElliptic) && BITRUNCATED) 
-    achievement_gain("HALLOWEEN2", rg::special_geometry);
+EX void achievement_collection2(eItem it, int q) {
+  if(cheater && !test_achievements) return;
+  if(casual && !test_achievements) return;
+  if(randomPatternsMode) return;
+  LATE( achievement_collection2(it, q); )
+
+  if(it == itTreat && q == 50)
+    achievement_gain("HALLOWEEN1", specgeom_halloween());
+
+  if(it == itTreat && q == 100)
+    achievement_gain("HALLOWEEN2", specgeom_halloween());
 
   if(q == 1) {
     if(it == itDiamond) achievement_gain("DIAMOND1");
@@ -213,17 +338,27 @@ void achievement_collection(eItem it, int prevgold, int newgold) {
     
     if(it == itRuins) achievement_gain("RUIN1");
     if(it == itSwitch) achievement_gain("JELLZ1");
+    
+    if(it == itBrownian) achievement_gain("BROWN1");
+    if(it == itVarTreasure) achievement_gain("RADIO1");
+    if(it == itWest) achievement_gain("FREEFALL1");
+    
+    if(it == itFrog) achievement_gain("FROG1");
+    if(it == itEclectic) achievement_gain("ECLEC1");
+    if(it == itWet) achievement_gain("WET1");
+
+    if(it == itCursed) achievement_gain("CURSED1");
+    if(it == itDice) achievement_gain("DICE1");
     }
 
   // 32
   if(it == itHolyGrail) {
     if(q == 1) achievement_gain("GRAIL2");
-    if(PURE && geometry == gNormal)
-      achievement_gain("GRAILH", rg::special_geometry);
-    if(PURE && geometry == gCrystal && ginf[gCrystal].sides == 8 && ginf[gCrystal].vertex == 4 && !crystal::used_compass_inside)
-      achievement_gain("GRAIL4D", rg::special_geometry);
-    if(BITRUNCATED && geometry == gCrystal && ginf[gCrystal].sides == 8 && ginf[gCrystal].vertex == 3 && !crystal::used_compass_inside)
-      achievement_gain("GRAIL4D2", rg::special_geometry);
+    achievement_gain("GRAILH", specgeom_heptagonal());
+    #if CAP_CRYSTAL
+    achievement_gain("GRAIL4D", specgeom_crystal1());
+    achievement_gain("GRAIL4D2", specgeom_crystal2());
+    #endif
     if(q == 3) achievement_gain("GRAIL3");
     if(q == 8) achievement_gain("GRAIL4");
     }
@@ -290,6 +425,17 @@ void achievement_collection(eItem it, int prevgold, int newgold) {
 
     if(it == itRuins) achievement_gain("RUIN2");
     if(it == itSwitch) achievement_gain("JELLZ2");
+
+    if(it == itBrownian) achievement_gain("BROWN2");
+    if(it == itVarTreasure) achievement_gain("RADIO2");
+    if(it == itWest) achievement_gain("FREEFALL2");
+    
+    if(it == itFrog) achievement_gain("FROG2");
+    if(it == itEclectic) achievement_gain("ECLEC2");
+    if(it == itWet) achievement_gain("WET2");
+
+    if(it == itCursed) achievement_gain("CURSED2");
+    if(it == itDice) achievement_gain("DICE2");
     }
 
   if(q == (inv::on ? 50 : 25)) {
@@ -357,6 +503,17 @@ void achievement_collection(eItem it, int prevgold, int newgold) {
 
     if(it == itRuins) achievement_gain("RUIN3");
     if(it == itSwitch) achievement_gain("JELLZ3");
+
+    if(it == itBrownian) achievement_gain("BROWN3");
+    if(it == itVarTreasure) achievement_gain("RADIO3");
+    if(it == itWest) achievement_gain("FREEFALL3");
+    
+    if(it == itFrog) achievement_gain("FROG3");
+    if(it == itEclectic) achievement_gain("ECLEC3");
+    if(it == itWet) achievement_gain("WET3");
+
+    if(it == itCursed) achievement_gain("CURSED3");
+    if(it == itDice) achievement_gain("DICE3");
     }
 
   if(q == 50 && !inv::on) {
@@ -421,6 +578,17 @@ void achievement_collection(eItem it, int prevgold, int newgold) {
 
     if(it == itRuins) achievement_gain("RUIN4");
     if(it == itSwitch) achievement_gain("JELLZ4");
+
+    if(it == itBrownian) achievement_gain("BROWN4");
+    if(it == itVarTreasure) achievement_gain("RADIO4");
+    if(it == itWest) achievement_gain("FREEFALL4");
+    
+    if(it == itFrog) achievement_gain("FROG4");
+    if(it == itEclectic) achievement_gain("ECLEC4");
+    if(it == itWet) achievement_gain("WET4");
+
+    if(it == itCursed) achievement_gain("CURSED4");
+    if(it == itDice) achievement_gain("DICE4");
     }
   
   if(it == itOrbYendor) {
@@ -430,10 +598,19 @@ void achievement_collection(eItem it, int prevgold, int newgold) {
     }
   }
 
-void achievement_count(const string& s, int current, int prev) {
-  if(cheater) return;
+/** This function awards 'counting' achievements, such as kill 10 monsters at the same time.
+ *  @param s name of the group of achievements, e.g. GOLEM.
+ *  @param current our score, e.g., the the achievement GOLEM2 will be awared with current >= 5.
+ *  @param prev previous value of the score.
+ */
+
+EX void achievement_count(const string& s, int current, int prev) {
+  if(cheater && !test_achievements) return;
+  if(casual && !test_achievements) return;
   if(shmup::on) return;
   if(randomPatternsMode) return;
+  LATE( achievement_count(s, current, prev); )
+
   if(s == "GOLEM" && current >= 5)
     achievement_gain("GOLEM2");
   if(s == "GOLEM" && current >= 10)
@@ -464,22 +641,27 @@ void achievement_count(const string& s, int current, int prev) {
     achievement_gain("LIGHTNING2");
   if(s == "LIGHTNING" && current-prev >= 10)
     achievement_gain("LIGHTNING3");
-  if(s == "MIRAGE" && current >= 35 && geometry == gEuclid)
-    achievement_gain("MIRAGE", rg::special_geometry);
+  if(s == "MIRAGE" && current >= 35)
+    achievement_gain("MIRAGE", specgeom_euclid_gen());
   if(s == "ORB" && current >= 10)
     achievement_gain("ORB3");
   if(s == "BUG" && current >= 1000)
     achievement_gain("BUG3");
   if(s == "ELEC" && current >= 10)
     achievement_gain("ELEC3");
+  if(s == "BOWVARIETY" && current >= 2)
+    achievement_gain("BOWVARIETY1");
+  if(s == "BOWVARIETY" && current >= 6)
+    achievement_gain("BOWVARIETY2");
   }
 
 int specific_improved = 0;
 int specific_what = 0;
 
-void improve_score(int i, eItem what) {
+EX void improve_score(int i, eItem what) {
   if(offlineMode) return;
-#ifdef HAVE_ACHIEVEMENTS
+  LATE( improve_score(i, what); )
+#if CAP_ACHIEVE
   if(haveLeaderboard(i)) updateHi(what, get_currentscore(i));
   if(items[what] && haveLeaderboard(i)) {
     if(items[what] > get_currentscore(i) && score_loaded(i)) {
@@ -490,26 +672,38 @@ void improve_score(int i, eItem what) {
 #endif
   }
 
-void achievement_score(int cat, int number) {
+// scores for special challenges
+EX void achievement_score(int cat, int number) {
   if(offlineMode) return;
-#ifdef HAVE_ACHIEVEMENTS
+#if CAP_ACHIEVE
   if(cheater) return;
+  if(casual) return;
+  LATE( achievement_score(cat, number); )
+  if(disksize) return;
   if(cat == LB_HALLOWEEN) {
     if(geometry != gSphere && geometry != gElliptic)
       return;
     }
-  else if(geometry) return;
+  else {
+    if(geometry) return;
+    if(ineligible_starting_land) return;
+    }
   if(CHANGED_VARIATION) return;
   if(randomPatternsMode) return;
-  if(shmup::on && cat != LB_PURE_TACTICS_SHMUP && cat != LB_PURE_TACTICS_COOP) return;
+  if(dual::state) return;
+  if(shmup::on && cat != LB_PURE_TACTICS_SHMUP && cat != LB_PURE_TACTICS_COOP && cat != LB_RACING) return;
   if(yendor::on && cat != LB_YENDOR_CHALLENGE) return;
   if(tactic::on && cat != LB_PURE_TACTICS && cat != LB_PURE_TACTICS_SHMUP && cat != LB_PURE_TACTICS_COOP) 
     return;
+  if(racing::on && cat != LB_RACING) return;
+  if(bow::weapon) return;
+  if(use_custom_land_list) return;
   upload_score(cat, number);
 #endif
   }
 
-void improveItemScores() {
+EX void improveItemScores() {
+  LATE( improveItemScores(); )
   for(int i=1; i<=12; i++) improve_score(i, eItem(i));
   improve_score(17, itOrbYendor);
   improve_score(18, itFernFlower);
@@ -564,19 +758,36 @@ void improveItemScores() {
   
   improve_score(76, itRuins);
   improve_score(77, itSwitch);
+  
+  improve_score(78, itBrownian);
+  improve_score(79, itVarTreasure);
+  improve_score(80, itWest);
+  
+  improve_score(82, itFrog);
+  improve_score(83, itEclectic);
+  improve_score(84, itWet);
+
+  improve_score(85, itCursed);
+  improve_score(86, itDice);
   }
 
 int next_stat_tick;
 
-void achievement_final(bool really_final) {
+/** gain the final achievements. 
+ *  @param really false: the user is simply looking at the score; true: the game really ended.
+ */
+EX void achievement_final(bool really_final) {
   if(offlineMode) return;
 
-#ifdef HAVE_ACHIEVEMENTS
+  LATE( achievement_final(really_final); )
+
+#if CAP_ACHIEVE
   if(ticks > next_stat_tick) {
     upload_score(LB_STATISTICS, time(NULL));
     next_stat_tick = ticks + 600000;
     }
   if(cheater) return;
+  if(casual) return;
 
 #if CAP_TOUR
   if(tour::on) return;
@@ -585,6 +796,7 @@ void achievement_final(bool really_final) {
   if(randomPatternsMode) return;
   if(peace::on) return;
   if(yendor::on) return;
+  if(dual::state) return;
 
   if(tactic::on) {
     tactic::record();
@@ -602,10 +814,15 @@ void achievement_final(bool really_final) {
   
   int specialcode = 0;
   if(shmup::on) specialcode++;
-  if(chaosmode) specialcode+=2;
+  if(ls::std_chaos()) specialcode+=2;
+  else if(!ls::nice_walls()) return;
   if(PURE) specialcode+=4;
   if(numplayers() > 1) specialcode+=8;
   if(inv::on) specialcode+=16;
+  if(bow::crossbow_mode() && bow::style == bow::cbBull) specialcode += 32;
+  if(bow::crossbow_mode() && bow::style == bow::cbGeodesic) specialcode += 64;
+  if(bow::crossbow_mode() && bow::style == bow::cbGeometric) specialcode += 96;
+  if(shmup::on && vid.creature_scale != 1) return;
   
   if(sphere && specialland == laHalloween) {
     if(specialcode) return;
@@ -613,8 +830,14 @@ void achievement_final(bool really_final) {
     return;
     }
 
+  if(ineligible_starting_land) return;
   if(geometry) return;
   if(NONSTDVAR) return;
+  if(use_custom_land_list) return;
+
+  if(numplayers() > 1 && !multi::friendly_fire) return;
+  if(numplayers() > 1 && multi::pvp_mode) return;
+  if(numplayers() > 1 && multi::split_screen) return;
   
   // determine the correct leaderboard ID for 'total score'
   // or return if no leaderboard for the current mode
@@ -627,6 +850,9 @@ void achievement_final(bool really_final) {
     case 8:  sid = 61; break;
     case 9:  sid = 44; break;
     case 16: sid = 69; break;
+    case 32: sid = 87; break;
+    case 64: sid = 88; break;
+    case 96: sid = 89; break;
     default: return;
     }
       
@@ -670,24 +896,30 @@ void achievement_final(bool really_final) {
 #endif
   }
 
-bool hadtotalvictory;
+EX bool hadtotalvictory;
 
-void check_total_victory() {
+EX void check_total_victory() {
   if(!inv::on) return;
   if(hadtotalvictory) return;
   if(!items[itOrbYendor]) return;
   if(!items[itHolyGrail]) return;
   if(items[itHyperstone] < 50) return;
   if(!princess::reviveAt) return;
+  LATE( check_total_victory(); )
   hadtotalvictory = true;
   achievement_gain("TOTALVICTORY");
   }
   
-void achievement_victory(bool hyper) {
-  DEBB(DF_STEAM, (debugfile,"achievement_victory\n"))
+/** gain the victory achievements. 
+ *  @param hyper true for the Hyperstone victory, and false for the Orb of Yendor victory.
+ */
+EX void achievement_victory(bool hyper) {
+  DEBBI(DF_STEAM, ("achievement_victory"))
   if(offlineMode) return;
-#ifdef HAVE_ACHIEVEMENTS
+#if CAP_ACHIEVE
   if(cheater) return;
+  if(casual) return;
+  if(bow::weapon) return;
   if(geometry) return;
   if(CHANGED_VARIATION) return;
   if(randomPatternsMode) return;
@@ -695,8 +927,11 @@ void achievement_victory(bool hyper) {
   if(yendor::on) return;
   if(peace::on) return;
   if(tactic::on) return;
-  if(chaosmode) return;
-  DEBB(DF_STEAM, (debugfile,"after checks\n"))
+  if(!ls::nice_walls()) return;
+  if(ineligible_starting_land) return;
+  if(use_custom_land_list) return;
+  LATE( achievement_victory(hyper); )
+  DEBB(DF_STEAM, ("after checks"))
 
   int t = getgametime();
   
@@ -747,20 +982,77 @@ void achievement_victory(bool hyper) {
       }
     }
   
-  DEBB(DF_STEAM, (debugfile, "uploading scores\n"))
+  DEBB(DF_STEAM, ("uploading scores"))
   upload_score(ih1, t);
   upload_score(ih2, turncount);
 #endif
   }
 
-void achievement_pump();
+/** call the achievement callbacks */
+EX void achievement_pump();
 
-#ifndef HAVE_ACHIEVEMENTS
-void achievement_pump() {}
-#endif
+EX string get_rich_presence_text() {
 
-void achievement_display() {
-  #ifdef HAVE_ACHIEVEMENTS
+  #if CAP_DAILY
+  if(daily::on)
+    return "Strange Challenge #" + its(daily::daily_id) + ", score " + its(gold());
+  #endif
+  
+  if(tour::on)
+    return "Guided Tour";
+
+  string res;
+  if(geometry != gNormal || !BITRUNCATED || disksize)
+    res = res + full_geometry_name() + " ";
+  
+  if(land_structure != default_land_structure()) res += land_structure_name(false) + " ";
+  if(shmup::on) res += "shmup ";
+  if(dual::state) res += "dual ";
+  if(randomPatternsMode) res += "random ";
+  if(inv::on) res += "OSM ";
+  if(multi::players > 1) res += "multi ";
+  if(casual) res += "casual ";
+  if(bow::weapon) res += bow::style == bow::cbBull ? "bow/bull " : "bow/geo ";
+
+  if(cheater || among(cwt.at->land, laCanvas, laCA)) 
+    return res + "(?)";
+  
+  if(yendor::on) {
+    res += "Yendor Challenge: " + yendor::name(yendor::challenge);
+    if(items[itOrbYendor]) res += " (level " + its(items[itOrbYendor]) + ")";
+    return res;
+    }
+  
+  if(peace::on) return res + "peaceful";
+
+  if(tactic::on)
+    return res + "PTM: " + linf[specialland].name + " $" + its(gold());
+
+  if(princess::challenge) return res + "Princess Challenge";
+
+  #if CAP_RACING
+  if(racing::on) {
+    using namespace racing;
+    res = res + "racing in " + linf[specialland].name;
+    
+    for(int i=0; i<multi::players; i++) {
+      if(race_finish_tick[i]) 
+        res += racetimeformat(race_finish_tick[i] - race_start_tick);
+      }
+    
+    return res;
+    }
+  #endif
+  
+  res += linf[cwt.at->land].name;
+  res += ", " + its(gold()) + " $$$";
+  
+  return res;
+  }
+
+/** display the last achievement gained. */
+EX void achievement_display() {
+  #if CAP_ACHIEVE
   if(achievementTimer) {
     int col = (ticks - achievementTimer);
     if(col > 5000) { achievementTimer = 0; return; }
@@ -768,12 +1060,12 @@ void achievement_display() {
     col /= 10; col *= 0x10101;
     displayfr(vid.xres/2, vid.yres/4, 2, vid.fsize * 2, achievementMessage[0], col & 0xFFFF00, 8);
     int w = 2 * vid.fsize;
-#if ISMOBILE==0
+#if !ISMOBILE
     while(w>3 && textwidth(w, achievementMessage[1]) > vid.xres) w--;
 #endif
     displayfr(vid.xres/2, vid.yres/4 + vid.fsize*2, 2, w, achievementMessage[1], col, 8);
     w = vid.fsize;
-#if ISMOBILE==0
+#if !ISMOBILE
     while(w>3 && textwidth(w, achievementMessage[2]) > vid.xres) w--;
 #endif
     displayfr(vid.xres/2, vid.yres/4 + vid.fsize*4, 2, w, achievementMessage[2], col, 8);
@@ -781,18 +1073,13 @@ void achievement_display() {
   #endif
   }
 
-bool isAscending(int i) { 
+EX bool isAscending(int i) { 
   return i == 13 || i == 14 || i == 15 || i == 16 || i == 29 || i == 30 || i == 45;
-  };
+  }
 
-int score_default(int i) {
+EX int score_default(int i) {
   if(isAscending(i)) return 1999999999;
   else return 0;
   }
 
-#ifndef HAVE_ACHIEVEMENTS
-int get_sync_status() { return 0; }
-void set_priority_board(int) { }
-#endif
-
 }

asonov.cpp

@@ -0,0 +1,268 @@
+// Hyperbolic Rogue -- Arnold's cat map
+// Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details
+
+/** \file asonov.cpp 
+ *  \brief Arnold's cat map
+ */
+
+
+#include "hyper.h"
+
+//#include <cstdio>
+//#include <cmath>
+
+namespace hr {
+
+EX namespace asonov {
+
+#if !CAP_SOLV
+#if HDR
+inline bool in() { return false; }
+#endif
+#endif
+
+EX int period_xy = 8;
+EX int period_z = 8;
+
+#if CAP_SOLV
+
+EX bool in() { return cgflags & qCAT; }
+
+EX hyperpoint tx, ty, tz;
+EX transmatrix straighten;
+
+#if HDR
+struct coord: public array<int,3> {
+  coord() {}
+  coord(int x, int y, int z) : array<int,3>(make_array(zgmod(x, period_xy), zgmod(y, period_xy), zgmod(z, period_z))) {}
+  coord shift(int x, int y, int z=0) { return coord(self[0]+x, self[1]+y, self[2]+z); }
+  coord up() { return coord(self[0]*2-self[1], self[1]-self[0], self[2]+1); }
+  coord down() { return coord(self[0]+self[1], self[0]+self[1]*2, self[2]-1); }  
+  coord addmove(int d);
+  coord operator - (coord b);
+  };
+#endif
+
+coord coord::addmove(int d) {
+  switch(d) {
+    case 0: return up().shift(0, 0);
+    case 1: return up().shift(1, -1);
+    case 2: return up().shift(-1, 0);
+    case 3: return up().shift(0, -1);
+    case 4: return shift(1, 0);
+    case 5: return shift(0, 1);
+    case 6: return down().shift(0, 0);
+    case 7: return down().shift(0, 1);
+    case 8: return down().shift(1, 1);
+    case 9: return down().shift(1, 2);
+    case 10: return shift(-1, 0);
+    case 11: return shift(0, -1);
+    default: throw hr_exception("error");
+    }
+  }
+
+EX void prepare() {
+  using namespace hr;
+  transmatrix A = Id;
+  A[0][0] = 1;
+  A[0][1] = 1;
+  A[1][0] = 1;
+  A[1][1] = 2;
+  
+  double det = hr::det(A);
+  if(det != 1) { printf("wrong det\n"); return; }
+  
+  // (a00-x)(a11-x) - a01*a10 = 0
+  
+  // x^2 - (a00+a11) x + 1 = 0
+  
+  double b = (A[0][0] + A[1][1]) / 2;
+
+  // x^2 - 2b x + b^2 = b^2-1
+  
+  // if(b*b <= 1) { printf("imaginary eigenvalues\n"); return 0; }
+  
+  // x = b + sqrt(b^2-1)
+  
+  hyperpoint lambda;
+  lambda[0] = b + sqrt(b*b-1);
+  lambda[1] = b - sqrt(b*b-1);
+  
+  DEBB(DF_GEOM, ("b = ", b, " lambda = ", lambda));
+  
+  transmatrix eigen = Id;
+  
+  for(int i: {0,1}) {    
+    eigen[0][i] = 1;
+    eigen[1][i] = (lambda[i] - A[0][0]) / A[0][1];
+    }
+  
+  transmatrix ieigen = inverse(eigen);
+  
+  tx = point3(ieigen[0][0], ieigen[1][0], 0) * vid.binary_width;
+  ty = point3(ieigen[0][1], ieigen[1][1], 0) * vid.binary_width;
+  tz = -point3(0, 0, log(lambda[0]));
+  
+  DEBB(DF_GEOM, ("tx = ", tx, " ty = ", ty, " tz = ", tz));
+  
+  straighten = inverse(build_matrix(asonov::tx/2, asonov::ty/2, asonov::tz/2, C0));
+  }
+
+EX void prepare_walls() {
+
+  auto& hsh = get_hsh();
+  auto& cs = hsh.faces;
+  cs.clear();
+  
+  auto pt = [&] (int x, int y, int z) { return asonov::tx*x/2 + asonov::ty*y/2 + asonov::tz*z/2 + C0; };
+  
+  cs.push_back({pt(-1,-1,+1), pt(00,+1,+1), pt(+1,+1,+1)});
+  cs.push_back({pt(00,-1,+1), pt(+1,+1,+1), pt(+1,-1,+1)});
+  cs.push_back({pt(-1,+1,+1), pt(00,+1,+1), pt(-1,-1,+1)});
+  cs.push_back({pt(-1,-1,+1), pt(+1,+1,+1), pt(00,-1,+1)});
+  cs.push_back({pt(+1,-1,-1), pt(+1,00,-1), pt(+1,+1,-1), pt(+1,+1,+1), pt(+1,-1,+1)});
+  cs.push_back({pt(-1,+1,-1), pt(-1,+1,+1), pt(00,+1,+1), pt(+1,+1,+1), pt(+1,+1,-1)});
+  cs.push_back({pt(-1,-1,-1), pt(-1,00,-1), pt(+1,-1,-1)});
+  cs.push_back({pt(-1,00,-1), pt(-1,+1,-1), pt(+1,-1,-1)});
+  cs.push_back({pt(-1,+1,-1), pt(+1,00,-1), pt(+1,-1,-1)});
+  cs.push_back({pt(-1,+1,-1), pt(+1,+1,-1), pt(+1,00,-1)});
+  cs.push_back({pt(-1,+1,-1), pt(-1,00,-1), pt(-1,-1,-1), pt(-1,-1,+1), pt(-1,+1,+1)});
+  cs.push_back({pt(+1,-1,-1), pt(+1,-1,+1), pt(00,-1,+1), pt(-1,-1,+1), pt(-1,-1,-1)});
+  
+  hsh.compute_hept();
+  }
+
+transmatrix coord_to_matrix(coord c, coord zero) {
+  transmatrix T = Id;
+
+  while(zero[2] != c[2]) {
+    int z = szgmod(c[2] - zero[2], period_z);
+    if(z > 0) zero = zero.up(), T = eupush(tz) * eupush(ty/2) * T;
+    else zero = zero.down(), T = eupush(-ty/2) * eupush(-tz) * T;
+    }
+  return T * eupush(tx * szgmod(c[0]-zero[0], period_xy) + ty * szgmod(c[1]-zero[1], period_xy));
+  }
+
+coord coord::operator - (coord b) {
+  auto c = self;
+  while(b[2]) {
+    int z = szgmod(b[2], period_z);
+    if(z > 0) b = b.down(), c = c.down();
+    else if(z < 0) b = b.up(), c = c.up();
+    }
+  c[0] = zgmod(c[0]-b[0], period_xy); b[0] = 0;
+  c[1] = zgmod(c[1]-b[1], period_xy); b[1] = 0;
+  return c;
+  }
+
+EX transmatrix adjmatrix(int i) {
+  dynamicval<int> pxy(period_xy, 64);
+  dynamicval<int> pz(period_z, 64);
+  coord zero(0,0,0);
+  coord c = zero.addmove(i);
+  return coord_to_matrix(c, zero);
+  }
+  
+struct hrmap_asonov : hrmap {
+  map<coord, heptagon*> at;
+    map<heptagon*, coord> coords;
+    
+  heptagon *getOrigin() override { return get_at(coord(0,0,0)); }
+    
+  hrmap_asonov() { prepare(); }
+  
+  ~hrmap_asonov() {
+    for(auto& p: at) clear_heptagon(p.second);
+    }
+
+  heptagon *get_at(coord c) {
+    auto& h = at[c];
+    if(h) return h;
+    h = init_heptagon(S7);
+    h->c7 = newCell(S7, h);
+    coords[h] = c;
+    h->distance = c[2];
+    h->zebraval = c[0];
+    h->emeraldval = c[1];
+    return h;      
+    }
+  
+  heptagon *create_step(heptagon *parent, int d) override {
+    auto p = coords[parent];
+    auto q = p.addmove(d);
+    auto child = get_at(q);
+    parent->c.connect(d, child, (d + 6) % 12, false);
+    return child;
+    }
+  
+  transmatrix adj(heptagon *h, int i) override { return adjmatrix(i); }
+  
+  transmatrix relative_matrixh(heptagon *h2, heptagon *h1, const hyperpoint& hint) override { 
+    for(int a=0; a<S7; a++) if(h2 == h1->move(a)) return adjmatrix(a);
+    return coord_to_matrix(coords[h2], coords[h1]);
+    }
+  };
+
+EX hrmap *new_map() { return new hrmap_asonov; }
+
+EX coord get_coord(heptagon *h) { return ((hrmap_asonov*)currentmap)->coords[h]; }
+
+EX heptagon *get_at(coord where) { return ((hrmap_asonov*)currentmap)->at[where]; }
+
+EX int period_xy_edit, period_z_edit;
+
+EX void set_flags() {
+  auto& flag = ginf[gArnoldCat].flags;
+  set_flag(flag, qANYQ, period_xy || period_z);
+  set_flag(flag, qCLOSED, period_xy && period_z);
+  set_flag(flag, qSMALL, period_xy && period_z && (period_xy * period_xy * period_z <= 4096));
+  set_flag(flag, qHUGE_BOUNDED, period_xy * period_xy * period_z > 16384);
+  }
+
+EX void prepare_config() {
+  period_xy_edit = period_xy;
+  period_z_edit = period_z;
+  }
+  
+EX void show_config() {
+  cmode = sm::SIDE | sm::MAYDARK;
+  gamescreen();
+  dialog::init(XLAT("Solv quotient spaces"));
+
+  dialog::addSelItem(XLAT("%1 period", "X/Y"), its(period_xy_edit), 'x');
+  dialog::add_action([=] { 
+    dialog::editNumber(period_xy_edit, 0, 64, 1, 0, XLAT("%1 period", "X/Y"), 
+      XLAT("Note: the value 0 functions effectively as the size of int (2^32).")
+      ); 
+    dialog::bound_low(0);
+    });      
+
+  dialog::addSelItem(XLAT("%1 period", "Z"), its(period_z_edit), 'z');
+  dialog::add_action([=] { 
+    dialog::editNumber(period_z_edit, 0, 64, 1, 0, XLAT("%1 period", "Z"), 
+      XLAT("Set to 0 to make it non-periodic.")
+      ); 
+    dialog::bound_low(0);
+    });      
+
+  dialog::addBreak(50);
+
+  dialog::addItem(XLAT("activate"), 'a');
+  dialog::add_action([] {
+    stop_game();
+    period_xy = period_xy_edit;
+    period_z = period_z_edit;
+    set_flags();
+    geometry = gArnoldCat;
+    start_game();
+    });
+    
+  dialog::addBreak(50);
+  dialog::addBack();
+  dialog::display();
+  }
+
+#endif
+
+}
+}

autogen.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-autoreconf -vfi
-./configure "$@"
-echo "Now, just do \"make install\" "
-

blizzard.cpp

@@ -1,48 +1,58 @@
-// Hyperbolic Rogue -- special graphical effects, such as the Blizzard
-// Copyright (C) 2011-2018 Zeno Rogue, see 'hyper.cpp' for details
+// Hyperbolic Rogue -- Blizzard
+// Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details
 
+/** \file blizzard.cpp 
+ *  \brief special graphical effects, such as the Blizzard and arrow traps
+ */
+
+#include "hyper.h"
 namespace hr {
 
 struct snowball {
   transmatrix T;
-  transmatrix global;
+  shiftmatrix global;
   snowball *prev;
   snowball *next;
   double phase;
   snowball(int t) { T = rgpushxto0(randomPointIn(t)); phase = randd(); }
   };                                                                
 
+#if HDR
+struct blizzardcell;
+#endif
+
 struct blizzardcell {
   cell *c;
   int frame;
   int tmp;
-  transmatrix *gm;
+  shiftmatrix *gm;
   char wmap;
   int inward, outward, ward;
-  int qty[MAX_EDGE];
+  vector<int> qty;
   vector<snowball*> inorder, outorder;
   int inid, outid;
   ~blizzardcell() { for(auto i: inorder) delete i; }
   };
 
-map<cell*, blizzardcell> blizzardcells;
+EX map<cell*, blizzardcell> blizzardcells;
 
-void set_blizzard_frame(cell *c, int frameid) {
+EX void set_blizzard_frame(cell *c, int frameid) {
   blizzardcells[c].frame = frameid;
   }
 
-vector<blizzardcell*> bcells;
+EX vector<blizzardcell*> bcells;
 
 int blizzard_N;
 
-blizzardcell* getbcell(cell *c) {
+EX blizzardcell* getbcell(cell *c) {
   int i = c->listindex;
   if(i<0 || i >= blizzard_N) return NULL;
   if(bcells[i]->c != c) return NULL;
   return bcells[i];
   }
 
-void drawBlizzards() {
+EX void drawBlizzards() {
+  #if CAP_SHAPES && CAP_FIELD
   poly_outline = OUTLINE_NONE;
   auto it = blizzardcells.begin();
   bcells.clear();
@@ -67,6 +77,7 @@ void drawBlizzards() {
     auto& bc = *bcells[i];
     cell *c = bc.c;
     bc.inward = bc.outward = 0;
+    bc.qty.resize(c->type);
     for(int i=0; i<c->type; i++) {
       int& qty = bc.qty[i];
       qty = 0;
@@ -112,15 +123,15 @@ void drawBlizzards() {
       sball.next = &sball2;
       sball2.prev = &sball;
       
-      hyperpoint t = inverse(sball.global) * tC0(sball2.global);
+      hyperpoint t = inverse_shift(sball.global, tC0(sball2.global));
       double at0 = at + sball.phase;
       if(at0>1) at0 -= 1;
-      transmatrix tpartial = sball.global * rspintox(t) * xpush(hdist0(t) * at0);
+      shiftmatrix tpartial = sball.global * rspintox(t) * xpush(hdist0(t) * at0);
       
       if(wmascii || wmblack)
-        queuechr(tpartial, .2, '.', 0xFFFFFF);
+        queuestr(tpartial, .2, ".", 0xFFFFFF);
       else
-        queuepoly(tpartial, shSnowball, 0xFFFFFF80);
+        queuepoly(tpartial, cgi.shSnowball, 0xFFFFFF80);
       }
     }
 
@@ -129,9 +140,9 @@ void drawBlizzards() {
 
     /* if(isNeighbor(bc.c, mouseover)) {
       if(againstWind(mouseover, bc.c))
-        queuepoly(*bc.gm, shHeptaMarker, 0x00C00040);
+        queuepoly(*bc.gm, cgi.shHeptaMarker, 0x00C00040);
       if(againstWind(bc.c, mouseover))
-        queuepoly(*bc.gm, shHeptaMarker, 0xC0000040);
+        queuepoly(*bc.gm, cgi.shHeptaMarker, 0xC0000040);
       } */
 
     forCellIdEx(c2, i, bc.c) if(bc.c == mouseover || c2 == mouseover) {
@@ -143,7 +154,7 @@ void drawBlizzards() {
       if(isPlayerOn(bc.c))
         col ^= 0x00000040;
       if(againstWind(bc.c, c2))
-        queuepoly(*bc.gm * ddspin(bc.c, i) * xpush(cellgfxdist(bc.c, i)/2), shWindArrow, col);
+        queuepoly(*bc.gm * ddspin(bc.c, i) * xpush(cellgfxdist(bc.c, i)/2), cgi.shWindArrow, col);
       }
 
     int B = isize(bc.outorder);
@@ -201,42 +212,57 @@ void drawBlizzards() {
 
   for(auto bc: bcells)
     bc->c->listindex = bc->tmp;
+  #endif
   }
        
-vector<cell*> arrowtraps;
+EX vector<cell*> arrowtraps;
 
-void drawArrowTraps() {
+EX void drawArrowTraps() {
   for(cell *c: arrowtraps) {
     auto r = traplimits(c);
     
     try {
-      transmatrix& t0 = gmatrix.at(r[0]);
-      transmatrix& t1 = gmatrix.at(r[4]);
+      shiftmatrix& t0 = gmatrix.at(r[0]);
+      shiftmatrix& t1 = gmatrix.at(r[4]);
+      ignore(t0);
+      ignore(t1);
 
+      #if CAP_QUEUE
       queueline(tC0(t0), tC0(t1), 0xFF0000FF, 4 + vid.linequality, PPR::ITEM);
+      #endif
+      #if CAP_SHAPES
       if((c->wparam & 7) == 3 && !shmup::on) {
 //        queueline(t0 * randomPointIn(r[0]->type), t1 * randomPointIn(r[1]->type), 0xFFFFFFFF, 4, PPR::ITEM);
         int tt = int(fractick(64) * 401);
         
         for(int u=0; u<2; u++) {
-          transmatrix& tu = u ? t0 : t1;
-          transmatrix& tv = u ? t1 : t0;
-          hyperpoint trel = inverse(tu) * tC0(tv);
-          transmatrix tpartial = tu * rspintox(trel) * xpush(hdist0(trel) * tt / 401.0);
-          queuepoly(tpartial * ypush(.05), shTrapArrow, 0xFFFFFFFF);
+          shiftmatrix& tu = u ? t0 : t1;
+          shiftmatrix& tv = u ? t1 : t0;
+          hyperpoint trel = inverse_shift(tu, tC0(tv));
+          shiftmatrix tpartial = tu * rspintox(trel) * xpush(hdist0(trel) * tt / 401.0);
+          tpartial = tpartial * ypush(.05);
+          if(GDIM == 3) tpartial = tpartial * cspin90(1, 2);
+          queuepoly(tpartial, cgi.shTrapArrow, 0xFFFFFFFF);
           }
         }
+      #endif
       }
     catch(out_of_range&) {}
     }
   }
 
-auto ccm_blizzard = addHook(clearmemory, 0, [] () {
+auto ccm_blizzard = addHook(hooks_clearmemory, 0, [] () {
   arrowtraps.clear();
   blizzardcells.clear();
   bcells.clear();
   }) + 
-addHook(hooks_removecells, 0, [] () {
++ addHook(hooks_gamedata, 0, [] (gamedata* gd) {
+  gd->store(arrowtraps);
+  gd->store(blizzardcells);
+  gd->store(bcells);
+  gd->store(blizzard_N);
+  })
++ addHook(hooks_removecells, 0, [] () {
   eliminate_if(arrowtraps, is_cell_removed);
   });
 

checkmove.cpp

@@ -0,0 +1,484 @@
+// Hyperbolic Rogue - checkmate rule
+// Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details
+
+/** \file checkmove.cpp
+ *  \brief Check the validity of move (checkmate rule)
+ */
+
+#include "hyper.h"
+
+namespace hr {
+
+#if HDR
+#define PUREHARDCORE_LEVEL 10
+#endif
+
+/** are we in the hardcore mode */
+EX bool hardcore = false;
+/** when did we switch to the hardcore mode */
+EX int hardcoreAt;
+/** are we in the casual mode */
+EX bool casual = false;
+
+EX bool pureHardcore() { return hardcore && hardcoreAt < PUREHARDCORE_LEVEL; }
+
+/** can we still move? */
+EX bool canmove = true;
+
+// how many monsters are near
+EX eMonster who_kills_me;
+EX cell *who_kills_me_cell;
+
+EX int lastkills;
+
+EX vector<bool> legalmoves;
+
+#if HDR
+struct moveissue {
+  int type;
+  int subtype;
+  eMonster monster;
+  cell *where;
+  };
+
+static constexpr int miVALID = 10000;
+static constexpr int miENTITY = 11000;
+static constexpr int miRESTRICTED = 10100;
+static constexpr int miTHREAT = 10010;
+static constexpr int miWALL = 10001;
+
+static constexpr int siWALL = 1;
+static constexpr int siMONSTER = 2;
+static constexpr int siGRAVITY = 3;
+static constexpr int siROSE = 4;
+static constexpr int siITEM = 5;
+static constexpr int siWIND = 6;
+static constexpr int siCURRENT = 7;
+static constexpr int siFATIGUE = 8;
+static constexpr int siWARP = 9;
+static constexpr int siUNKNOWN = 10;
+#endif
+
+/* why is a move illegal */
+EX vector<moveissue> move_issues;
+
+EX moveissue checked_move_issue;
+EX moveissue stay_issue;
+EX int yasc_code;
+
+EX void check_if_monster() {
+  eMonster m = cwt.peek()->monst;
+  if(m && m != passive_switch && !isFriendly(m))
+    checked_move_issue = moveissue { miENTITY, siMONSTER, m, cwt.peek() };
+  }
+  
+EX bool hasSafeOrb(cell *c) {
+  return 
+    c->item == itOrbSafety ||
+    c->item == itOrbShield ||
+    c->item == itOrbShell  ||
+    (c->item == itOrbYendor && yendor::state(c) == yendor::ysUnlocked);
+  }
+
+#if HDR
+struct player_move_info {
+  movei mi;
+  cell *swordlast[2], *swordtransit[2], *swordnext[2];
+  player_move_info(movei mi);
+  };
+#endif
+
+EX vector<player_move_info> pmi;
+EX vector<cell*> pushes;
+
+player_move_info::player_move_info(movei _mi) : mi(_mi) {
+  for(int b=0; b<2; b++) swordlast[b] = sword::pos(multi::cpid, b);
+
+  dynamicval<sword::sworddir> x7(sword::dir[multi::cpid], sword::shift(mi, sword::dir[multi::cpid]));
+  
+  for(int b=0; b<2; b++) {
+    swordnext[b] = sword::pos(multi::cpid, b);
+    swordtransit[b] = NULL;
+    if(swordnext[b] && swordnext[b] != swordlast[b] && !isNeighbor(swordlast[b], swordnext[b])) {
+      forCellEx(c2, swordnext[b])
+        if(c2 != mi.t && c2 != mi.s && isNeighbor(c2, S3==3 ? swordlast[b] : mi.t))
+          swordtransit[b] = c2;
+      if(S3 == 4)
+        forCellEx(c2, mi.s)
+          if(c2 != mi.s && isNeighbor(c2, swordlast[b]))
+            swordtransit[b] = c2;
+      }
+    }
+  }
+
+EX bool krakensafe(cell *c) {
+  return items[itOrbFish] || items[itOrbAether] || 
+    (c->item == itOrbFish && c->wall == waBoat) || 
+    (c->item == itOrbAether && c->wall == waBoat);
+  }
+
+EX bool monstersnear(cell *c, eMonster who) {
+
+  bool eaten = false;
+
+  if(hardcore && who == moPlayer) return false;
+
+  int res = 0;
+  bool fast = false;
+  bool kraken_will_destroy_boat = false;
+
+  elec::builder b;
+  if(elec::affected(c)) { who_kills_me = moLightningBolt; who_kills_me_cell = nullptr; res++; }
+  
+  if(c->wall == waArrowTrap && c->wparam == 2) {
+    who_kills_me = moArrowTrap; who_kills_me_cell = nullptr; res++;
+    }
+  
+  for(auto c1: crush_now) if(c == c1) {
+    who_kills_me = moCrusher; who_kills_me_cell = nullptr; res++;
+    }
+
+  if(who == moPlayer || items[itOrbEmpathy]) {
+    fast = (items[itOrbSpeed] && (items[itOrbSpeed] & 1));
+    if(who == moPlayer && !isPlayerOn(c) && c->item == itOrbSpeed && !items[itOrbSpeed]) fast = true;
+    }
+  
+  if(havewhat&HF_OUTLAW) {
+    for(cell *c1: gun_targets(c)) 
+      if(c1->monst == moOutlaw && !c1->stuntime) {
+        res++; who_kills_me = moOutlaw; who_kills_me_cell = c1;
+        }
+    }
+
+  for(int t=0; t<c->type; t++) {
+    cell *c2 = c->move(t);
+
+    // consider monsters who attack from distance 2
+    if(c2) forCellEx(c3, c2) if(c3 != c) {
+      // only these monsters can attack from two spots...
+      if(!among(c3->monst, moLancer, moWitchSpeed, moWitchFlash)) 
+        continue;
+      if(c3->monst == moWitchSpeed && cwt.at->land != laPower)
+        continue;
+      // take logical_adjacent into account
+      if(c3->monst != moWitchFlash)
+        if(!logical_adjacent(c3, c3->monst, c2) || !logical_adjacent(c2, c3->monst, c) || (c3->monst == moWitchSpeed && c2->land != laPower))
+          continue;
+      if(elec::affected(c3)) continue;
+      if(c3->stuntime > (who == moPlayer ? 0 : 1)) continue;
+      // speedwitches can only attack not-fastened monsters,
+      // others can only attack if the move is not fastened
+      if(c3->monst == moWitchSpeed && items[itOrbSpeed]) continue;
+      if(c3->monst != moWitchSpeed && fast) continue;
+      // cannot attack if the immediate cell is impassable (except flashwitches)
+      if(c3->monst != moWitchFlash) {
+        if(!passable(c2, c3, 0)) continue;
+        if(isPlayerOn(c2) && items[itOrbFire]) continue;
+        }
+      // flashwitches cannot attack if it would kill another enemy
+      if(c3->monst == moWitchFlash && flashWouldKill(c3, 0)) continue;
+      res++, who_kills_me = c3->monst; who_kills_me_cell = c3;
+      } 
+
+    // consider normal monsters
+    if(c2 && isArmedEnemy(c2, who)) {
+      eMonster m = c2->monst;
+      if(elec::affected(c2)) continue;
+      if(fast && c2->monst != moWitchSpeed) continue;
+      // Krakens just destroy boats
+      if(who == moPlayer && c2->monst == moKrakenT && c->wall == waBoat && !peace::on) {
+        kraken_will_destroy_boat = true;
+        continue;
+        }
+      // they cannot attack through vines
+      if(!canAttack(c2, c2->monst, c, who, AF_NEXTTURN)) continue;
+      if(c2->monst == moWorm || c2->monst == moTentacle || c2->monst == moHexSnake) {
+        if(passable_for(c2->monst, c, c2, 0))
+          eaten = true;
+        else if(c2->monst != moHexSnake) continue;
+        }
+      res++, who_kills_me = m; who_kills_me_cell = c2;
+      }
+    }
+
+  if(kraken_will_destroy_boat && !krakensafe(c) && warningprotection(XLAT("This move appears dangerous -- are you sure?"))) {
+    if (res == 0) who_kills_me = moWarning; who_kills_me_cell = nullptr;
+    res++;
+  } else {
+    if(who == moPlayer && res && (markOrb2(itOrbShield) || markOrb2(itOrbShell)) && !eaten)
+      res = 0;
+    if(who == moPlayer && res && markOrb2(itOrbDomination) && c->monst)
+      res = 0;
+  }
+
+  return !!res;
+  }
+
+EX bool monstersnear_aux() {
+  changes.value_set(passive_switch, (gold() & 1) ? moSwitch1 : moSwitch2);
+  multi::cpid++;
+  bool b = false;
+  if(multi::cpid == multi::players || multi::players == 1 || multi::checkonly) {
+
+    if(shmup::delayed_safety) return false;
+    
+    for(int i=0; i<isize(pmi); i++)
+    for(int j=0; j<isize(pmi); j++) if(i != j) {
+      if(swordConflict(pmi[i], pmi[j])) {
+          b = true;
+          who_kills_me = moEnergySword;
+          }
+      if(pmi[i].mi.t == pmi[j].mi.t) 
+        { b = true; who_kills_me = moFireball; }
+      if(celldistance(pmi[i].mi.t, pmi[j].mi.t) > 8) 
+        { b = true; who_kills_me = moAirball; }
+      }
+
+    for(auto& pushto: pushes)
+    for(auto& mi: pmi)
+      if(pushto == mi.mi.t) {
+        b = true; who_kills_me = moTongue;
+        }
+        
+    for(int i=0; i<isize(pushes); i++)
+      for(int j=0; j<i; j++)
+        if(pushes[i] == pushes[j]) {
+          b = true; who_kills_me = moCrushball;
+          }
+          
+    for(int i=0; !b && i<isize(pmi); i++)
+      b = monstersnear(pmi[i].mi.t, moPlayer);
+    }
+  else b = !multimove();
+  multi::cpid--;
+  return b;
+  }
+
+/** like monstersnear but add the potential moves of other players into account */
+EX bool monstersnear_add_pmi(player_move_info pmi0) {
+  if(suicidal) {
+    who_kills_me = moPlayer; who_kills_me_cell = nullptr;
+    return true;
+    }
+  pmi.push_back(pmi0);
+  bool b = monstersnear_aux();
+  pmi.pop_back();
+  return b;
+  }
+
+EX bool multimove() {
+  if(multi::cpid == 0) lastkills = tkills();
+  if(!multi::playerActive(multi::cpid)) return !monstersnear_aux();
+  cellwalker bcwt = cwt;
+  cwt = multi::player[multi::cpid];
+  bool b = movepcto(multi::whereto[multi::cpid]);
+  if(b) {
+    multi::aftermove = true;
+    multi::player[multi::cpid] = cwt;
+    multi::whereto[multi::cpid].d = MD_UNDECIDED;
+    int curkills = tkills();
+    multi::kills[multi::cpid] += (curkills - lastkills);
+    lastkills = curkills;
+    }
+  cwt = bcwt;
+  return b;
+  }
+
+EX namespace multi { 
+  EX bool checkonly = false;
+  EX bool aftermove;
+  EX }
+
+EX bool swordConflict(const player_move_info& sm1, const player_move_info& sm2) {
+  if(items[itOrbSword] || items[itOrbSword2])
+  for(int b=0; b<2; b++)
+    if(sm1.mi.s == sm2.swordlast[b] || sm1.mi.s == sm2.swordtransit[b] || sm1.mi.s == sm2.swordnext[b])
+    if(sm1.mi.t == sm2.swordlast[b] || sm1.mi.t == sm2.swordtransit[b] || sm1.mi.t == sm2.swordnext[b])
+      return true;
+  return false;
+  }
+
+EX string yasc_message;
+
+EX string blocking_monster_name(const moveissue& mi) {
+  if(mi.monster == moKnight && mi.where)
+    return XLAT("%1 the Knight", camelot::knight_name(mi.where));
+  else
+    return dnameof(mi.monster);
+  }
+
+EX void create_yasc_message() {
+  set<pair<cell*, string>> captures;
+  auto all = move_issues;
+  all.push_back(stay_issue);
+  for(auto c: all) if(c.type == miTHREAT) captures.emplace(c.where, blocking_monster_name(c));
+
+  vector<string> context;
+  if(!captures.empty()) {
+    string msg = "captured by ";
+    map<string, int> qties;
+    for(auto ca: captures) qties[ca.second]++;
+    int iqties = 0;
+    for(auto q: qties) {
+      if(iqties && iqties == isize(qties) - 1) msg += " and ";
+      else if(iqties) msg += ", ";
+      msg += q.first;
+      if(q.second > 1) msg += " (x" + its(q.second) + ")";
+      iqties++;
+      }
+    context.push_back(msg);
+    }
+
+  int idx = 0;
+  for(auto c: all) if(idx == 0 && c.subtype == siROSE) context.push_back("rosed"), idx = 1;
+  for(auto c: all) if(idx < 2 && c.subtype == siWIND) context.push_back("blown away"), idx = 2;
+  for(auto c: all) if(idx < 3 && c.subtype == siGRAVITY) context.push_back("falling"), idx = 3;
+  for(auto c: all) if(idx < 4 && c.subtype == siFATIGUE) context.push_back("fatigued"), idx = 4;
+  for(auto c: all) if(idx < 5 && c.subtype == siCURRENT) context.push_back("whirled"), idx = 5;
+
+  bool in_ctx = true;
+
+  set<string> blocks;
+  int index = 0;
+  for(auto c: all) {
+    if(c.type == miENTITY && !captures.count({c.where, blocking_monster_name(c)})) blocks.insert(blocking_monster_name(c));
+    else if(c.type == miWALL && c.subtype == siMONSTER && !captures.count({c.where, blocking_monster_name(c)})) blocks.insert(blocking_monster_name(c));
+    else if(c.subtype == siITEM) blocks.insert("item");
+    else if(c.subtype == siWALL) {
+      if(c.where == cwt.at) {
+        if(in_ctx) {
+          if(c.where->wall == waNone && c.where->land == laBrownian)
+            context.push_back("on level 3");
+          else if(c.where->wall == waRoundTable)
+            context.push_back("being polite");
+          else
+            context.push_back(winf[c.where->wall].flags & WF_ON ? XLAT("on %the1", c.where->wall) : XLAT("in %the1", c.where->wall));
+          }
+        in_ctx = false;
+        }
+      else if(c.where && c.where->wall != cwt.at->wall) blocks.insert(dnameof(c.where->wall));
+      }
+    else if(c.type == siWARP) blocks.insert("warp");
+    index++;
+    }
+
+  if(!blocks.empty()) {
+    string block = "blocked by ";
+    int iqties = 0;
+    for(auto& q: blocks) {
+      if(iqties && iqties == isize(blocks) - 1) block += " and ";
+      else if(iqties) block += ", ";
+      block += q;
+      iqties++;
+      }
+    context.push_back(block);
+    }
+
+  yasc_message = "";
+  int iqties = 0;
+  for(auto& ctx: context) {
+    if(iqties == 0) ;
+    else if(iqties == 1) yasc_message += " while ";
+    else if(iqties == isize(context) - 1) yasc_message += " and ";
+    else yasc_message += ", ";
+    yasc_message += ctx;
+    iqties++;
+    }
+
+  if(captures.size() == 2 && context.size() == 1 && cwt.at->type == 6) {
+    vector<int> dirs;
+    forCellIdEx(c1, i, cwt.at) for(auto cap: captures) if(cap.first == c1) dirs.push_back(i);
+    if(isize(dirs) == 2 && abs(dirs[0]-dirs[1]) == 3) {
+      auto c1 = captures.begin(); c1++;
+      yasc_message = XLAT("pinched by %the1 and %the2", captures.begin()->second, c1->second);
+      }
+    }
+
+  println(hlog, "YASC_MESSAGE: ", yasc_message);
+  }
+
+int yasc_recode(int x) {
+  if(cwt.at->type < 10 || x == 0) return x;
+  return yasc_recode(x / 10) * 100 + (x % 10);
+  };
+
+EX void checkmove() {
+
+  if(dual::state == 2) return;
+  if(shmup::on) return;
+
+  dynamicval<eGravity> gs(gravity_state, gravity_state);
+
+#if CAP_INV
+  if(inv::on) inv::compute();
+#endif
+
+  if(multi::players > 1 && !multi::checkonly) return;
+  if(hardcore) return;
+  
+  legalmoves.clear(); legalmoves.resize(cwt.at->type+1, false);
+  move_issues.clear(); move_issues.resize(cwt.at->type);
+
+  canmove = haveRangedTarget();
+  items[itWarning]+=2;
+  if(movepcto(-1, 0, true))
+    canmove = legalmoves[cwt.at->type] = true;
+  stay_issue = checked_move_issue;
+  
+  if(true) {
+    for(int i=0; i<cwt.at->type; i++) {
+      dynamicval<bool> fm(bow::fire_mode, false);
+      if(movepcto(1, -1, true)) {
+        canmove = legalmoves[cwt.spin] = true;
+        }
+      check_if_monster();
+      move_issues[cwt.spin] = checked_move_issue;
+      if(!legalmoves[cwt.spin]) {
+        if(movepcto(0, 1, true)) {
+          canmove = legalmoves[cwt.spin] = true;
+          }
+        check_if_monster();
+        move_issues[cwt.spin] = checked_move_issue;
+        }
+      }
+    }
+  if(kills[moPlayer]) canmove = false;
+  
+  yasc_code = 0;
+  for(int i=0; i<cwt.at->type; i++)
+    yasc_code += yasc_recode(move_issues[i].type);
+
+  if(!canmove && bow::crossbow_mode() && !items[itCrossbow]) canmove = bow::have_bow_target();
+
+#if CAP_INV  
+  if(inv::on && !canmove && !inv::incheck) {
+    if(inv::remaining[itOrbSafety] || inv::remaining[itOrbFreedom])
+      canmove = true;
+    else {
+      inv::check(1);
+      checkmove();
+      inv::check(-1);
+      }
+    if(canmove)
+      pushScreen(inv::show);
+    }
+#endif
+
+  if(!canmove) {
+    create_yasc_message();
+    achievement_final(true);
+    if(cmode & sm::NORMAL) showMissionScreen();
+    }
+  else yasc_message = "";
+
+  if(canmove && timerstopped) {
+    timerstart = time(NULL);
+    timerstopped = false;
+    }
+  items[itWarning]-=2;
+
+  if(recallCell.at && !markOrb(itOrbRecall)) activateRecall();  
+  }
+
+
+}

classes.h

@@ -1,304 +0,0 @@
-namespace hr {
-
-typedef unsigned color_t;
-
-typedef unsigned long long flagtype;
-#define Flag(i) (flagtype(1ull<<i))
-
-static inline void set_flag(flagtype& f, flagtype which, bool b) {
-  if(b) f |= which;
-  else f &= ~which;
-  }
-
-static const int motypes = 162;
-
-struct monstertype {
-  char  glyph;
-  color_t color;
-  const char *name;
-  const char *help;
-  };
-
-enum eMonster { 
-  moNone, 
-  moYeti, moWolf, moWolfMoved, 
-  moRanger, 
-  moTroll, moGoblin, 
-  moWorm, moWormtail, moWormwait, moHedge, 
-  moDesertman, 
-  moIvyRoot, moIvyHead, moIvyBranch, moIvyWait, moIvyNext, moIvyDead,
-  moMonkey,
-  moSlime,
-  moMimic, moREMOVED, moGolem, moGolemMoved,
-  moEagle, moSeep,
-  moZombie, moGhost, moNecromancer, moShadow,
-  moTentacle, moTentacletail, moTentaclewait, moTentacleEscaping, 
-  moCultist, moPyroCultist,
-  moGreater, moGreaterM, moLesser, moLesserM,
-  moShark, moRunDog, moGreaterShark, moFireFairy,
-  moCrystalSage, moLancer, moFlailer, moMiner,
-  moVineBeast, moVineSpirit, moDarkTroll, moEarthElemental,
-  moBug0, moBug1, moBug2, 
-  moWitch, moWitchSpeed, moWitchFlash, moWitchFire, moWitchWinter, moWitchGhost,
-  moEvilGolem, moKnight, moCultistLeader, moSlimeNextTurn, moKnightMoved,
-  moIllusion,
-  moPirate, moCShark, moParrot,
-  moHexSnake, moHexSnakeTail, moRedTroll, moBomberbird, moAlbatross,
-  moTameBomberbird, moTameBomberbirdMoved,
-  moPalace, moFatGuard, moSkeleton, moVizier,
-  moViking, moFjordTroll, moWaterElemental,
-  moMouse, moMouseMoved, 
-  moPrincess, moPrincessMoved, 
-  moPrincessArmed, moPrincessArmedMoved,
-  moFamiliar, moGargoyle, moFireElemental, moAirElemental,
-  moOrangeDog, moTentacleGhost,
-  moMetalBeast, moMetalBeast2, moOutlaw, moMutant, 
-  moStormTroll, moForestTroll, 
-  moRedFox, moWindCrow, moFriendlyGhost, moRatling, moFalsePrincess, moRoseLady,
-  moRoseBeauty, moRatlingAvenger,
-  moTortoise, moDragonHead, moDragonTail,
-  moGadfly, moResearcher, moSparrowhawk,
-  moKrakenH, moKrakenT, moDraugr, moFriendlyIvy,
-  moVampire, moBat, moReptile, 
-  moHerdBull, moRagingBull, moSleepBull,
-  moButterfly, moNarciss, moMirrorSpirit,
-  moHunterDog, moTerraWarrior, moJiangshi, moVoidBeast, moLavaWolf, moHunterGuard,
-  moIceGolem, moSandBird, moSalamander, moHunterChanging,
-  moNorthPole, moSouthPole,
-  moPair, moHexDemon, moAltDemon, moMonk, moCrusher,
-  moSwitch1, moSwitch2,
-  // shmup specials
-  moPlayer, moBullet, moFlailBullet, moFireball, moTongue, moAirball, moCrushball,
-  // temporary
-  moDeadBug, moLightningBolt, moDeadBird, moEnergySword, moWarning, moArrowTrap,
-  moRogueviz
-  };
-
-struct genderswitch_t {
-  int gender;
-  eMonster m;
-  const char *name;
-  const char *desc;
-  };
-
-#define NUM_GS 6
-
-static const int ittypes = 130;
-
-struct itemtype {
-  char  glyph;
-  color_t color;
-  const char *name;
-  const char *help;
-  };
-
-enum eItem { 
-  itNone, itDiamond, itGold, itSpice, itRuby, itElixir, itShard, itBone, itHell, itStatue,
-  itFeather, itSapphire, itHyperstone, itKey,
-  itGreenStone, itOrbYendor,
-  itOrbLightning, itOrbFlash, itOrbWinter, itOrbSpeed, itOrbLife, itOrbShield, itOrbDigging,
-  itOrbTeleport, itOrbSafety,
-  itOrbThorns, itFernFlower,
-  itWine, itOrbAether, itSilver, itOrbPsi,
-  itRoyalJelly, itEmerald, itOrbInvis, itPower, itOrbFire,
-  itHolyGrail, itGrimoire,
-  itOrbDragon, itOrbIllusion,
-  itPirate, itCompass,
-  itRedGem, itOrbTime, itOrbSpace,
-  itBombEgg, itCoast, itWhirlpool,
-  itOrbFriend, itOrbWater, itOrbAir,
-  itPalace, itOrbFrog,
-  itFjord, itOrbFish,
-  itOrbDiscord,
-  itSavedPrincess, itOrbLove,
-  itIvory, itZebra, 
-  itFireShard, itAirShard, itEarthShard, itWaterShard,
-  itElemental, itOrbSummon, itOrbMatter,
-  itBounty, itRevolver, itFulgurite, itMutant,
-  itOrbStunning, itOrbLuck, 
-  itMutant2, itOrbFreedom, itLotus, itOrbUndeath,
-  itWindstone, itOrbEmpathy, itStrongWind, itBuggy, itBuggy2,
-  itRose, itCoral, itOrbBeauty, itOrb37, itOrbEnergy,
-  itBabyTortoise, itOrbShell, itApple, itDragon, itOrbDomination,
-  itOrbSword, itKraken, itOrbSword2, itBarrow,
-  itTrollEgg, itWarning, itOrbStone, itOrbNature, itTreat,
-  itSlime, itAmethyst, itOrbRecall, itDodeca, itOrbDash, itGreenGrass, itOrbHorns,
-  itOrbBull, itBull, itOrbMirror,
-  itInventory,
-  itLavaLily, itHunting, itBlizzard, itTerra,
-  itOrbSide1, itOrbSide2, itOrbSide3,
-  itOrbLava, itOrbMorph, itGlowCrystal, itSnake,
-  itDock, itRuins, itMagnet, itSwitch,
-  itOrbPhasing, itOrbMagnetism, itOrbSlaying
-  };
-
-static const int walltypes = 109;
-
-struct walltype {
-  char  glyph;
-  color_t color;
-  const char *name;
-  const char *help;
-  };
-
-enum eWall { waNone, waIcewall, waBarrier, waFloorA, waFloorB, waCavewall, waCavefloor, waDeadTroll, waDune,
-  waMirror, waCloud, waThumperOff, waFire, waAncientGrave, waFreshGrave, waColumn, waSulphurC, waSulphur,
-  waLake, waFrozenLake, waChasm, waChasmD, waBigTree, waSmallTree, 
-  waVinePlant, waVineHalfA, waVineHalfB, waPartialFire, 
-  waDeadwall, waDeadfloor, waDeadfloor2, waWaxWall, waGlass, waCamelot, waRoundTable,
-  waCamelotMoat,
-  waBigStatue,
-  waSea, waBoat, waCIsland, waCIsland2, waCTree,
-  waRed1, waRed2, waRed3,
-  waMineUnknown, waMineMine, waMineOpen,
-  waStrandedBoat,
-  waPalace, waClosedGate, waOpenGate, waClosePlate, waOpenPlate, waTrapdoor,
-  waGiantRug,
-  waPlatform, waGargoyle, waGargoyleFloor, waRubble, waLadder, waStone,
-  waBonfireOff, waThumperOn, waEternalFire,
-  waGargoyleBridge,
-  waTempWall, waTempFloor, waTempBridge,
-  waCharged, waGrounded, waSandstone, waSaloon, waMetal,
-  waDeadTroll2, waFan,
-  waTemporary, waEarthD, waElementalTmp, waElementalD,
-  waSlime1, waSlime2, waRose, waWarpGate,
-  waTrunk, waSolidBranch, waWeakBranch, waCanopy,
-  waBarrowWall, waBarrowDig,
-  waPetrified, waTower,
-  waBigBush, waSmallBush,
-  waReptile, waReptileBridge,
-  waInvisibleFloor,
-  waMirrorWall,
-  waPetrifiedBridge,
-  waTempBridgeBlocked,
-  waTerraWarrior, waBubble,
-  waArrowTrap, waMercury, waMagma,
-  waDock, waBurningDock, waRuinWall, waBrownian
-  };
-
-static const int landtypes = 85;
-
-struct landtype {
-  color_t color;
-  const char *name;
-  const char *help;
-  };
-
-enum eLand { laNone, laBarrier, laCrossroads, laDesert, laIce, laCaves, laJungle, laAlchemist, laMirror, laGraveyard,
-  laRlyeh, laHell, laCocytus, laMotion, laDryForest, laEmerald, laWineyard, laDeadCaves, 
-  laHive, laPower, laCamelot, laTemple, 
-  laCrossroads2, laCaribbean, laRedRock, laMinefield, laOcean, laWhirlpool,
-  laPalace, laLivefjord, 
-  laIvoryTower, laZebra, laEFire, laEAir, laEEarth, laEWater, laCrossroads3,
-  laOceanWall, laElementalWall, 
-  laCanvas, laPrincessQuest,
-  laWildWest, laStorms, laOvergrown, laClearing, 
-  laHaunted, laHauntedWall, laHauntedBorder,
-  laWhirlwind, laRose, laWarpCoast, laWarpSea, laCrossroads4,
-  laEndorian, laTortoise, laDragon,
-  laKraken, laBurial, laTrollheim,
-  laHalloween, laDungeon, laMountain, laReptile,
-  laPrairie, laBull, laCrossroads5, laCA,
-  laMirrorWall, laMirrored, laMirrorWall2, laMirrored2,
-  laMirrorOld,
-  laVolcano, laBlizzard, laHunting, laTerracotta, laMercuryRiver,
-  laDual, laSnakeNest, laDocks, laRuins, laMagnetic,
-  laSwitch, laMemory, laBrownian
-  };
-
-enum eGeometry {
-  gNormal, gEuclid, gSphere, gElliptic, gZebraQuotient, gFieldQuotient, gTorus, gOctagon, g45, g46, g47, gSmallSphere, gTinySphere, gEuclidSquare, gSmallElliptic, 
-  gKleinQuartic, gBolza, gBolza2, gMinimal, gBinaryTiling, gArchimedean, 
-  gMacbeath, gBring, gSchmutzM2, gSchmutzM3, gCrystal, gOctahedron,
-  gGUARD};
-
-enum eGeometryClass { gcHyperbolic, gcEuclid, gcSphere };
-
-enum class eVariation { bitruncated, pure, goldberg, irregular, dual };  
-
-struct geometryinfo {
-  const char* tiling_name;
-  const char* quotient_name;
-  const char* menu_displayed_name;
-  const char* shortname;
-  int sides;
-  int vertex;
-  flagtype flags;
-  eGeometryClass cclass;
-  int xcode;
-  std::array<int,2> distlimit; // bitrunc, non-bitrunc
-  eVariation default_variation;
-  };
-
-static const flagtype qBOUNDED         = 1;
-static const flagtype qANYQ            = 2;
-static const flagtype qNONORIENTABLE   = 4;
-static const flagtype qSMALL           = 8;
-
-static const flagtype qFIELD           = 16;
-static const flagtype qDOCKS           = 32;
-static const flagtype qZEBRA           = 64;
-
-// note: dnext assumes that x&7 equals 7
-static const int SEE_ALL = 50;
-static const int FORBIDDEN = -1;
-
-extern eGeometry geometry;
-extern eVariation variation;
-
-extern std::vector<geometryinfo> ginf;
-
-extern monstertype minf[motypes];
-extern itemtype iinf[ittypes];
-
-extern const landtype linf[landtypes];
-extern color_t floorcolors[landtypes];
-
-enum cpatterntype { 
-  cpFootball, cpThree, cpChess, cpSingle, cpSingleSym, cpOddEven, cpLarge, cpZebra, cpUnknown
-  };
-  
-struct landtacinfo { eLand l; int tries, multiplier; };
-
-enum eModel {
-  mdDisk, mdHalfplane, mdBand, mdPolygonal, mdFormula,
-  mdEquidistant, mdEquiarea, mdBall, mdHyperboloid, 
-  mdHemisphere, mdBandEquidistant, mdBandEquiarea, mdSinusoidal, mdTwoPoint, 
-  mdFisheye, mdJoukowsky, mdJoukowskyInverted,
-  mdRotatedHyperboles, mdSpiral,
-  mdGUARD, mdUnchanged, mdHyperboloidFlat, mdPolynomial
-  };
-
-typedef unsigned long long flagtype;
-
-namespace mf {
-  static const flagtype azimuthal = 1;
-  static const flagtype band = 2 + 512;
-  static const flagtype equiarea = 4;
-  static const flagtype equidistant = 8;
-  static const flagtype conformal = 16;
-  static const flagtype euc_boring = 32;
-  static const flagtype space = 64;
-  static const flagtype hyper_only = 128;
-  static const flagtype hyper_or_torus = 256;
-  static const flagtype quasiband = 512;
-  };
-  
-struct modelinfo {
-  const char *name_hyperbolic;
-  const char *name_euclidean;
-  const char *name_spherical;  
-  
-  flagtype flags;
-
-  int is_azimuthal;
-  int is_band;
-  int is_equiarea;
-  int is_equidistant;
-  int is_conformal;
-  const char* name;
-  };
-
-extern const modelinfo models[int(mdPolynomial)+1];
-
-}

colors.cpp

@@ -0,0 +1,312 @@
+// Hyperbolic Rogue -- color routines
+// Copyright (C) 2011-2020 Zeno Rogue, see 'hyper.cpp' for details
+
+/** \file colors.cpp 
+ *  \brief This file implements routines related to colors
+ */
+
+#include "hyper.h"
+namespace hr {
+
+/** \brief Return a reference to i-th component of col. 
+ *  \arg i For colors with alpha, A=0, R=1, G=2, B=3. For colors without alpha, R=0, G=1, B=2.
+ */
+EX unsigned char& part(color_t& col, int i) {
+  unsigned char* c = (unsigned char*) &col;
+#if ISMOBILE
+  return c[i];
+#else
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+  return c[sizeof(col) - 1 - i];
+#else
+  return c[i];
+#endif
+#endif
+  }
+
+#if HDR
+static constexpr color_t NOCOLOR = 0;
+
+struct colortable: vector<color_t> {
+  color_t& operator [] (int i) { i %= size(); if(i<0) i += size(); return ((vector<color_t>&)(*this)) [i]; }
+  const color_t& operator [] (int i) const { i %= size(); if(i<0) i += size(); return ((vector<color_t>&)(*this)) [i]; }
+  colortable(std::initializer_list<color_t> v) : vector(v) {}
+  colortable() : vector({0}) {}
+  void allocate(int num) {
+    int q = size();
+    for(int i=q; i<num; i++) push_back((*this)[i % q]);
+    }
+  };
+#endif
+
+/* darkening routines */
+
+EX color_t darkena3(color_t c, int lev, int a) {
+  return (darkenedby(c, lev) << 8) + a;
+  }
+
+EX color_t darkena(color_t c, int lev, int a) {
+  return darkena3(c, lev, GDIM == 3 ? 255 : a);
+  }
+
+EX int darkenedby(int c, int lev) {
+  for(int i=0; i<lev; i++)
+    c = ((c & 0xFEFEFE) >> 1);
+  return c;
+  }
+
+bool fading = false;
+
+ld fadeout = 1;
+
+EX color_t darkened(color_t c) {
+  if(inmirrorcount&1)
+    c = gradient(c, winf[waMirror].color, 0, 0.5, 1);
+  else if(inmirrorcount)
+    c = gradient(c, winf[waCloud].color, 0, 0.5, 1);
+  if(fading) c = gradient(backcolor, c, 0, fadeout, 1);
+  if(vid.desaturate) {
+    ld luminance = 0.2125 * part(c,2) + 0.7154 * part(c,1) + 0.0721 * part(c, 0);
+    c = gradient(c, int(luminance+.5) * 0x10101, 0, vid.desaturate, 100);
+    }
+  for(int i=0; i<darken; i++)
+    c = ((c & 0xFEFEFE) >> 1) + ((backcolor & 0xFEFEFE) >> 1);
+  return c;
+  }
+
+/* gradient interpolation */
+
+EX color_t gradient(color_t c0, color_t c1, ld v0, ld v, ld v1) {
+  int vv = int(256 * ((v-v0) / (v1-v0)));
+  color_t c = 0;
+  for(int a=0; a<4; a++) {
+    int p0 = part(c0, a);
+    int p1 = part(c1, a);
+    part(c, a) = (p0*(256-vv) + p1*vv + 127) >> 8;
+    }
+  return c;
+  }
+
+EX color_t rcolor() {
+  color_t res;
+  part(res, 0) = hrand(0x80);
+  part(res, 1) = hrand(256);
+  part(res, 2) = hrand(0x80) + 128;
+  swap(part(res, 1), part(res, rand() % 2));
+  swap(part(res, 2), part(res, rand() % 3));
+  return res;
+  }
+
+EX color_t rainbow_color(ld sat, ld hue) {
+  hue = frac(hue);
+  
+  if(hue < 0) hue++;
+  
+  hue *= 6;
+  
+  color_t res = 0;
+  
+  if(hue<1) res = gradient(0xFF0000, 0xFFFF00, 0, hue, 1);
+  else if(hue<2) res = gradient(0x00FF00, 0xFFFF00, 2, hue, 1);
+  else if(hue<3) res = gradient(0x00FF00, 0x00FFFF, 2, hue, 3);
+  else if(hue<4) res = gradient(0x0000FF, 0x00FFFF, 4, hue, 3);
+  else if(hue<5) res = gradient(0x0000FF, 0xFF00FF, 4, hue, 5);
+  else if(hue<=6) res = gradient(0xFF0000, 0xFF00FF, 6, hue, 5);
+  
+  return gradient(0xFFFFFF, res, 0, sat, 1);
+  }
+
+/** Adjust col to SDL_gfx functions. No adjustment is needed in SDL 1.2, but it is needed in SDL2 */
+EX color_t align(color_t col) {
+  #if CAP_SDL2
+  swap(part(col, 0), part(col, 3));
+  swap(part(col, 1), part(col, 2));
+  #endif
+  return col;
+  }
+
+#if HDR
+enum class eNeon { none, neon, no_boundary, neon2, illustration};
+#endif
+
+EX eNeon neon_mode;
+EX bool neon_nofill;
+
+EX void apply_neon(color_t& col, int& r) {
+  switch(neon_mode) {
+    case eNeon::none: 
+    case eNeon::illustration:
+      break;
+    case eNeon::neon: 
+      poly_outline = col << 8; col = 0; 
+      break;      
+    case eNeon::no_boundary: 
+      r = 0;
+      break;
+    case eNeon::neon2:
+      poly_outline = col << 8; col &= 0xFEFEFE; col >>= 1; 
+      break;
+    }
+  }
+
+/** used when neon_mode is eNeon::illustration */
+EX color_t magentize(color_t x) {
+  if(neon_mode != eNeon::illustration) return x;
+  int green = part(x,2);
+  int magenta = (part(x, 1) + part(x, 3)) / 2;
+  int nm = max(magenta, green);
+  int gm = (magenta + green)/2;
+  nm = (nm + 255) / 2;
+  gm = gm / 2;
+  
+  return (nm * 0x1000100) | (gm * 0x10000) | (part(x, 0));
+  }
+
+EX color_t monochromatize(color_t x) {
+  int c = part(x,2) + part(x,1) + part(x, 3);
+  c ++;
+  c /= 3;
+  return c * 0x1010100 | (part(x, 0));
+  }
+
+/** colorblind mode */
+EX bool cblind;
+
+/** apply neon_mode and cblind */
+EX void apply_neon_color(color_t col, color_t& pcolor, color_t& poutline, flagtype flags) {
+  if(cblind) {
+    // protanopia
+    /* int r = (56 * part(col,3) + 43 * part(col,2)) / 100;
+    int g = (58 * part(col,3) + 42 * part(col,2)) / 100;
+    int b = (24 * part(col,2) + 75 * part(col,1)) / 100; */
+    // deuteranopia
+    /* int r = (625 * part(col,3) + 375 * part(col,2)) / 1000;
+    int g = (700 * part(col,3) + 300 * part(col,2)) / 1000;
+    int b = (300 * part(col,2) + 700 * part(col,1)) / 1000; 
+    part(col,3) = r;
+    part(col,2) = g;
+    part(col,1) = b; */
+    part(col,2) = part(col,3) = (part(col,2) * 2 + part(col,3) + 1)/3;
+    }
+  if(neon_mode == eNeon::none) {
+    pcolor = (darkened(col >> 8) << 8) + (col & 0xFF);
+    poutline = poly_outline;
+    if(flags & POLY_TRIANGLES) poutline = 0;
+    }
+  else switch(neon_mode) {
+    case eNeon::neon:
+      pcolor = (poly_outline & 0xFFFFFF00) | (col & 0xFF);
+      poutline = (darkened(col >> 8) << 8) | (col & 0xFF);
+      if(col == 0xFF) poutline = 0xFFFFFFFF;
+      if(neon_nofill && pcolor == 0xFF) pcolor = 0; 
+      break;
+    case eNeon::no_boundary:
+      pcolor = (darkened(col >> 8) << 8) + (col & 0xFF);
+      poutline = 0;
+      break;
+    case eNeon::neon2:
+      pcolor = (darkened(col >> 8) << 8) + (col & 0xFF) + ((col & 0xFF) >> 2);
+      poutline = (darkened(col >> 8) << 8) + (col & 0xFF);
+      if(col == 0xFF) poutline = 0xFFFFFFFF;
+      if(poly_outline != 0xFF) poutline = poly_outline;
+      if(neon_nofill && pcolor == 0xFF) pcolor = 0; 
+      break;
+    case eNeon::illustration: {
+      if(poly_outline && (poly_outline>>8) != bordcolor) {
+        pcolor = magentize(col);
+        poutline = 0xFF;
+        }
+      else {
+        poutline = poly_outline;
+        pcolor = monochromatize(col);
+        }
+      if(pcolor & 0xFF) pcolor |= 0xFF;
+      if(poutline & 0xFF) poutline |= 0xFF;
+      break;
+      }
+    case eNeon::none: ;
+    }
+  }
+
+/* color of various stuff */
+
+/** cloak color for the given table radius */
+EX int cloakcolor(int rtr) {
+  rtr -= 28;
+  rtr /= 2;
+  rtr %= 10;
+  if(rtr < 0) rtr += 10;
+  // rtr = time(NULL) % 10;
+  int cc[10] = {
+    0x8080FF, 0x80FFFF, 0x80FF80, 0xFF8080, 0xFF80FF, 0xFFFF80, 
+    0xFFFFC0, 0xFFD500, 0x421C52, 0
+    };
+  return cc[rtr];
+  }
+
+EX int firegradient(double p) {
+  return gradient(0xFFFF00, 0xFF0000, 0, p, 1);
+  }
+
+constexpr ld PI1000 = 0.001 / A_PI;
+
+EX int firecolor(int phase IS(0), int mul IS(1)) {
+  return gradient(0xFFFF00, 0xFF0000, -1, sintick(100*mul, phase * 5 * PI1000), 1);
+  }
+
+EX int watercolor(int phase) {
+  return 0x0080C0FF + 256 * int(63 * sintick(50, phase * 10 * PI1000));
+  }
+
+EX int aircolor(int phase) {
+  return 0x8080FF00 | int(32 + 32 * sintick(200, phase * 1. / cgi.S21));
+  }
+
+EX int fghostcolor(cell *c) {
+  int phase = int(fractick(650, (int)(size_t)c) * 4000);
+  if(phase < 1000)      return gradient(0xFFFF80, 0xA0C0FF,    0, phase, 1000);
+  else if(phase < 2000) return gradient(0xA0C0FF, 0xFF80FF, 1000, phase, 2000);
+  else if(phase < 3000) return gradient(0xFF80FF, 0xFF8080, 2000, phase, 3000);
+  else if(phase < 4000) return gradient(0xFF8080, 0xFFFF80, 3000, phase, 4000);
+  return 0xFFD500;
+  }
+
+EX int weakfirecolor(int phase) {
+  return gradient(0xFF8000, 0xFF0000, -1, sintick(500, phase * PI1000), 1);
+  }
+
+/* HTML color names */
+
+EX vector<pair<const char*, color_t>> color_names = {
+{"aliceblue", 0xf0f8ff}, {"antiquewhite", 0xfaebd7}, {"aqua", 0x00ffff}, {"aquamarine", 0x7fffd4}, {"azure", 0xf0ffff},
+{"beige", 0xf5f5dc}, {"bisque", 0xffe4c4}, {"black", 0x000000}, {"blanchedalmond", 0xffebcd}, {"blue", 0x0000ff}, {"blueviolet", 0x8a2be2}, {"brown", 0xa52a2a}, {"burlywood", 0xdeb887},
+{"cadetblue", 0x5f9ea0}, {"chartreuse", 0x7fff00}, {"chocolate", 0xd2691e}, {"coral", 0xff7f50}, {"cornflowerblue", 0x6495ed}, {"cornsilk", 0xfff8dc}, {"crimson", 0xdc143c}, {"cyan", 0x00ffff},
+{"darkblue", 0x00008b}, {"darkcyan", 0x008b8b}, {"darkgoldenrod", 0xb8860b}, {"darkgray", 0xa9a9a9}, {"darkgreen", 0x006400}, {"darkkhaki", 0xbdb76b}, {"darkmagenta", 0x8b008b}, {"darkolivegreen", 0x556b2f},
+{"darkorange", 0xff8c00}, {"darkorchid", 0x9932cc}, {"darkred", 0x8b0000}, {"darksalmon", 0xe9967a}, {"darkseagreen", 0x8fbc8f}, {"darkslateblue", 0x483d8b}, {"darkslategray", 0x2f4f4f}, {"darkturquoise", 0x00ced1},
+{"darkviolet", 0x9400d3}, {"deeppink", 0xff1493}, {"deepskyblue", 0x00bfff}, {"dimgray", 0x696969}, {"dodgerblue", 0x1e90ff},
+{"firebrick", 0xb22222}, {"floralwhite", 0xfffaf0}, {"forestgreen", 0x228b22}, {"fuchsia", 0xff00ff},
+{"gainsboro", 0xdcdcdc}, {"ghostwhite", 0xf8f8ff}, {"gold", 0xffd700}, {"goldenrod", 0xdaa520}, {"gray", 0x808080}, {"green", 0x008000}, {"greenyellow", 0xadff2f},
+{"honeydew", 0xf0fff0}, {"hotpink", 0xff69b4},
+{"indianred ", 0xcd5c5c}, {"indigo", 0x4b0082}, {"ivory", 0xfffff0}, {"khaki", 0xf0e68c},
+{"lavender", 0xe6e6fa}, {"lavenderblush", 0xfff0f5}, {"lawngreen", 0x7cfc00}, {"lemonchiffon", 0xfffacd}, {"lightblue", 0xadd8e6}, {"lightcoral", 0xf08080}, {"lightcyan", 0xe0ffff}, {"lightgoldenrodyellow", 0xfafad2},
+{"lightgrey", 0xd3d3d3}, {"lightgreen", 0x90ee90}, {"lightpink", 0xffb6c1}, {"lightsalmon", 0xffa07a}, {"lightseagreen", 0x20b2aa}, {"lightskyblue", 0x87cefa}, {"lightslategray", 0x778899}, {"lightsteelblue", 0xb0c4de},
+{"lightyellow", 0xffffe0}, {"lime", 0x00ff00}, {"limegreen", 0x32cd32}, {"linen", 0xfaf0e6},
+{"magenta", 0xff00ff}, {"maroon", 0x800000}, {"mediumaquamarine", 0x66cdaa}, {"mediumblue", 0x0000cd}, {"mediumorchid", 0xba55d3}, {"mediumpurple", 0x9370d8}, {"mediumseagreen", 0x3cb371}, {"mediumslateblue", 0x7b68ee},
+{"mediumspringgreen", 0x00fa9a}, {"mediumturquoise", 0x48d1cc}, {"mediumvioletred", 0xc71585}, {"midnightblue", 0x191970}, {"mintcream", 0xf5fffa}, {"mistyrose", 0xffe4e1}, {"moccasin", 0xffe4b5},
+{"navajowhite", 0xffdead}, {"navy", 0x000080},
+{"oldlace", 0xfdf5e6}, {"olive", 0x808000}, {"olivedrab", 0x6b8e23}, {"orange", 0xffa500}, {"orangered", 0xff4500}, {"orchid", 0xda70d6},
+{"palegoldenrod", 0xeee8aa}, {"palegreen", 0x98fb98}, {"paleturquoise", 0xafeeee}, {"palevioletred", 0xd87093}, {"papayawhip", 0xffefd5}, {"peachpuff", 0xffdab9}, {"peru", 0xcd853f}, {"pink", 0xffc0cb}, {"plum", 0xdda0dd}, {"powderblue", 0xb0e0e6}, {"purple", 0x800080},
+{"rebeccapurple", 0x663399}, {"red", 0xff0000}, {"rosybrown", 0xbc8f8f}, {"royalblue", 0x4169e1},
+{"saddlebrown", 0x8b4513}, {"salmon", 0xfa8072}, {"sandybrown", 0xf4a460}, {"seagreen", 0x2e8b57}, {"seashell", 0xfff5ee}, {"sienna", 0xa0522d}, {"silver", 0xc0c0c0}, {"skyblue", 0x87ceeb}, {"slateblue", 0x6a5acd}, {"slategray", 0x708090}, {"snow", 0xfffafa}, {"springgreen", 0x00ff7f}, {"steelblue", 0x4682b4},
+{"tan", 0xd2b48c}, {"teal", 0x008080}, {"thistle", 0xd8bfd8}, {"tomato", 0xff6347}, {"turquoise", 0x40e0d0},
+{"violet", 0xee82ee},
+{"wheat", 0xf5deb3}, {"white", 0xffffff}, {"whitesmoke", 0xf5f5f5},
+{"yellow", 0xffff00}, {"yellowgreen", 0x9acd32}
+};
+
+EX pair<const char*, color_t>* find_color_by_name(const string& s) {
+  for(auto& c: color_names) if(c.first == s) return &c;
+  return nullptr;
+  }
+
+}

commandline.cpp

@@ -1,13 +1,26 @@
 // Hyperbolic Rogue -- commandline options
 // Copyright (C) 2011-2018 Zeno Rogue, see 'hyper.cpp' for details
 
+/** \file commandline.cpp 
+ *  \brief Commandline options support
+ */
+
+#include "hyper.h"
 namespace hr {
 
-#if CAP_COMMANDLINE
-const char *scorefile = "hyperrogue.log";
+#ifdef RESOURCEDESTDIR
+EX string rsrcdir = RESOURCEDESTDIR;
+#endif
 
-namespace arg {
-eLand readland(const string& ss) {
+#ifndef RESOURCEDESTDIR
+EX string rsrcdir = "";
+#endif
+
+#if CAP_COMMANDLINE
+EX string scorefile = "hyperrogue.log";
+
+EX namespace arg {
+EX eLand readland(const string& ss) {
   if(ss == "II") return laCrossroads2;
   if(ss == "III") return laCrossroads3;
   if(ss == "IV") return laCrossroads4;
@@ -19,7 +32,7 @@ eLand readland(const string& ss) {
   return laNone;
   }
 
-eItem readItem(const string& ss) {
+EX eItem readItem(const string& ss) {
   for(int i=0; i<ittypes; i++) if(appears(iinf[i].name, ss)) {
     return eItem(i);
     break;
@@ -27,16 +40,17 @@ eItem readItem(const string& ss) {
   return itNone;
   }
 
-eMonster readMonster(const string& ss) {
+EX eMonster readMonster(const string& ss) {
+  if(ss == "Pike") return moPike;
   for(int i=0; i<motypes; i++) if(appears(minf[i].name, ss)) {
     return eMonster(i);
     break;
     }
   return moNone;
   }
-}
+EX }
 
-void initializeCLI() {
+EX void initializeCLI() {
   printf("HyperRogue by Zeno Rogue <zeno@attnam.com>, version " VER "\n");
 
 #if !NOLICENSE
@@ -49,39 +63,91 @@ void initializeCLI() {
   if(getenv("HOME")) {
     sbuf = getenv("HOME"); sbuf += "/."; sbuf += scorefile;
     cbuf = getenv("HOME"); cbuf += "/."; cbuf += conffile;
-    scorefile = sbuf.c_str();
+    scorefile = sbuf;
     conffile = cbuf.c_str();
     }
   #endif
   }
 
-namespace arg {
-  vector<string> argument;
-  int pos;
+EX namespace arg {
+  EX int curphase;
 
-  void lshift() { pos++; }
+  EX vector<string> argument;
+  EX int pos;
 
-  void shift() {
-    lshift(); if(pos > isize(argument)) { printf("Missing parameter\n"); exit(1); }
+  EX void lshift() { pos++; }
+  EX void unshift() { pos--; }
+
+  EX void shift() {
+    lshift(); if(pos >= isize(argument)) { printf("Missing parameter\n"); exit(1); }
     }
   
-  const string& args() { return argument[pos]; }
-  const char* argcs() { return args().c_str(); }
-  int argi() { return atoi(argcs()); }
-  unsigned arghex() { return strtoll(argcs(), NULL, 16); }
-  ld argf() { return parseld(args()); }
-  bool argis(const string& s) { if(args()[0] == '-' && args()[1] == '-') return args().substr(1) == s; return args() == s; }
+  EX bool nomore() { return pos >= isize(argument); }
   
-  void init(int argc, char **argv) { for(int i=0; i<argc; i++) argument.push_back(argv[i]); shift(); }
+  EX const string& args() { return argument[pos]; }
+  EX const char* argcs() { return args().c_str(); }
+  EX int argi() { return atoi(argcs()); }
+  EX long long argll() { return atoll(argcs()); }
+
+  EX int shift_argi() { shift(); return argi(); }
+  EX const string& shift_args() { shift(); return args(); }
+
+  EX unsigned arghex() { return strtoll(argcs(), NULL, 16); }
+  EX ld argf() { 
+    try {
+      return parseld(args());
+      }
+    catch(hr_parse_exception& ex) {
+      println(hlog, "error parsing commandline parameters: ", ex.s);
+      exit(1);
+      }
+    }
+  EX bool argis(const string& s) { if(args()[0] == '-' && args()[1] == '-') return args().substr(1) == s; return args() == s; }
+
+  EX color_t argcolor(int bits) {
+    return parsecolor(args(), bits == 32);
+    }
+  
+  int parameter_id;
+
+  EX void shift_arg_formula(ld& x, const reaction_t& r IS(reaction_t())) {
+    shift();
+    auto par = anims::find_param(&x);
+    if(!par) par = param_f(x, "tmp_parameter_" + its(parameter_id++))->set_reaction(r);
+    par->load_as_animation(args());
+    }
+
+  #if HDR
+
+  // an useful macro
+  #define PHASE(x) { if(arg::curphase > x) arg::phaseerror(x); else if(arg::curphase < x) return 2; }
+  #define PHASEFROM(x) { if(arg::curphase < x) return 2; }
+
+  #define TOGGLE(x, param, act) \
+  else if(args()[0] == '-' && args()[1] == x && !args()[2]) { PHASEFROM(2); showstartmenu = false; act; } \
+  else if(args()[0] == '-' && args()[1] == x && args()[2] == '1') { PHASEFROM(2); showstartmenu = false; if(!param) act; } \
+  else if(args()[0] == '-' && args()[1] == x && args()[2] == '0') { PHASEFROM(2); showstartmenu = false; if(param) act; }
+
+  #endif
+
+  EX void cheat() { autocheat = true; cheater++; timerghost = false; }
+  
+  EX void run_arguments(const vector<string> vec) {
+    dynamicval<int> p(pos, 0);
+    dynamicval<vector<string>> orig(argument, vec);
+    read(3);
+    }
+
+  EX void init(int argc, char **argv) { for(int i=0; i<argc; i++) argument.push_back(argv[i]); lshift(); }
  
-  void phaseerror(int x) {
+  EX void phaseerror(int x) {
     printf("Command line error: cannot read command '%s' from phase %d in phase %d\n", args().c_str(), x, curphase);
     exit(1);
     }
 
   bool dialog_launched = false;
   
-  void launch_dialog(const reaction_t& r) {
+  EX void launch_dialog(const reaction_t& r IS(reaction_t())) {
     if(!dialog_launched) {
       popScreenAll();
       showstartmenu = false;
@@ -90,18 +156,35 @@ namespace arg {
     if(r) pushScreen(r);
     }
 
-  }
+  EX int readCommon();
+  EX int readLocal();  
+  EX void read(int phase);
+EX }
 
 
 int arg::readCommon() {
 
 // first phase options
 
-  if(argis("-s")) { PHASE(1); shift(); scorefile = argcs(); }
+  if(argis("-s")) { PHASE(2); shift(); scorefile = args(); savefile_selection = false; }
+  else if(argis("-no-s")) { PHASE(2); scorefile = ""; savefile_selection = false; }
+  else if(argis("-rsrc")) { PHASE(1); shift(); rsrcdir = args(); }
   else if(argis("-nogui")) { PHASE(1); noGUI = true; }
 #ifndef EMSCRIPTEN
-  else if(argis("-font")) { PHASE(1); shift(); fontpath = args(); }
+#if CAP_SDL
+  else if(argis("-font")) { PHASE(1); shift(); fontpath = args();
+    #ifdef FONTCONFIG
+    font_to_find = "";
+    #endif
+    }
+#ifdef FONTCONFIG
+  else if(argis("-find-font")) { PHASE(1); shift(); font_to_find = args(); }
 #endif
+#endif
+#endif
+
+  else if(argis("-test-ach")) 
+    test_achievements = true;
 
   else if(argis("-test")) 
     callhooks(hooks_tests);
@@ -109,13 +192,41 @@ int arg::readCommon() {
     PHASE(1);
     offlineMode = true;
     }
-  else if(argis("-debugf")) {
-    debugfile = fopen("hyperrogue-debug.txt", "w");
-    shift(); debugflags = argi();
+  else if(argis("-no-stamp")) {
+    debugflags &=~ DF_TIME;
     }
-  else if(argis("-debuge")) {
-    debugfile = stderr;
-    shift(); debugflags = argi();
+  else if(argis("-debf")) {
+    shift(); 
+    string s = args();
+    for(char c: s) {
+      for(int i=0; i<int(strlen(DF_KEYS)); i++) {
+        if(DF_KEYS[i] == c) debugflags |= (1<<i);
+        else if(DF_KEYS[i] == (c ^ 32)) debugflags &= ~(1<<i);
+        }
+      if(c >= '0' && c <= '9') {
+        debugflags &= DF_TIME;
+        if(c >= '1')
+          debugflags |= DF_INIT | DF_WARN | DF_MSG | DF_ERROR;
+        if(c >= '2')
+          debugflags |= DF_GEOM | DF_GP | DF_LOG | DF_FIELD | DF_POLY;
+        if(c >= '3')
+          debugflags |= DF_TURN | DF_STEAM;
+        if(c >= '4')
+          debugflags |= DF_GRAPH | DF_MEMORY;
+        }
+      else if(c == '+') {
+        if(debugfile) fclose(debugfile);
+        shift(); 
+        println(hlog, "writing to ", argcs());
+        debugfile = fopen(argcs(), "at");  
+        }
+      else if(c == '@') {
+        if(debugfile) fclose(debugfile);
+        shift(); 
+        println(hlog, "writing to ", argcs());
+        debugfile = fopen(argcs(), "wt");  
+        }
+      }
     }
   else if(argis("-run")) {
     PHASE(3); 
@@ -131,24 +242,68 @@ int arg::readCommon() {
     }
 #if CAP_TOUR
   else if(argis("-tour")) {
+    showstartmenu = false;
     PHASEFROM(2); start_game(); tour::start();
     }
   else if(argis("-presentation")) {
     PHASEFROM(2); tour::texts = false;
     start_game(); tour::start();
     }
+  else if(argis("-print-tour")) {
+    tour::print();
+    }
 #endif
   else if(argis("-draw")) {
-    PHASE(3); drawscreen();
+    PHASE(3); start_game(); drawscreen();
     }
-  else if(argis("-rotate")) {
+  else if(argis("-sview")) {
     PHASE(3);  start_game();
-    shift(); ld a = argf();
-    shift(); ld b = argf();
-    View = View * spin(M_PI * 2 * a / b);
+    playermoved = false;
+    transmatrix T = View;
+    shift(); View = parsematrix(args());
+    println(hlog, "View is set to ", View);
+    current_display->which_copy = View * inverse(T) * current_display->which_copy;
+    }
+  else if(argis("-rotate-up")) {
+    start_game();
+    shiftmatrix S = ggmatrix(cwt.at->master->move(0)->c7);
+    View = spin90() * spintox(S.T*C0) * View;
+    playermoved = false;
+    }
+  else if(argis("-face-vertex")) {
+    PHASE(3);  start_game();
+    auto &ss = currentmap->get_cellshape(cwt.at);
+    View = cspin90(0, 2) * spintox(ss.vertices_only_local[0]);
+    playermoved = false;
+    }
+  else if(argis("-face-face")) {
+    PHASE(3);  start_game();
+    View = cspin90(0, 2);
+    }
+  else if(argis("-center-vertex")) {
+    PHASE(3); shift(); int i = argi();
+    shift(); int j = argi();
+    shift(); int k = argi();
+    start_game();
+    auto fh = currentmap->get_cellshape(cwt.at).faces[j][k];
+    hyperpoint h = View * fh;
+    if(i == 0) {
+      shift_view_to(shiftless(h));
+      playermoved = false;
+      }
+    if(i == 1) {
+      rotate_view(spintox(h));
+      rotate_view(cspin90(0, 2));
+      }
     }
   else if(argis("-exit")) {
-    PHASE(3); printf("Success.\n");
+    PHASE(3);
+    int t = SDL_GetTicks();
+    if(t > 1800 * 1000)
+      println(hlog, "Great Success!\n");
+    else
+      println(hlog, "Success.\n");
+    fflush(stdout);
     exit(0);
     }
 
@@ -176,38 +331,58 @@ int arg::readCommon() {
     clearMessages();
     }
 
+  else if(argis("-save-mode")) {
+    save_mode_to_file(shift_args());
+    }
+
+  else if(argis("-load-mode")) {
+    try {
+      load_mode_from_file(shift_args());
+      }
+    catch(hstream_exception& e) {
+      println(hlog, "exception!");
+      }
+    }
+
 // informational
   else if(argis("-version") || argis("-v")) {
     printf("HyperRogue version " VER "\n");
     exit(0);
     }
   else if(argis("-L")) {
-    printf("Treasures:\n");
+    printf("+ Treasures:\n");
+    int qty = 0;
     for(int i=1; i<ittypes; i++) 
       if(itemclass(eItem(i)) == IC_TREASURE)
-        printf("    %s\n", iinf[i].name);
+        printf("    %s\n", iinf[i].name), qty++;
+    printf("    total = %d\n", qty); qty = 0;
     printf("\n");
-    printf("Orbs:\n");
+    printf("+ Orbs:\n");
     for(int i=1; i<ittypes; i++) 
       if(itemclass(eItem(i)) == IC_ORB)
-        printf("    %s\n", iinf[i].name);
+        printf("    %s\n", iinf[i].name), qty++;
+    printf("    total = %d\n", qty); qty = 0;
     printf("\n");
-    printf("Other items:\n");
+    printf("+ Other items:\n");
     for(int i=1; i<ittypes; i++) 
       if(itemclass(eItem(i)) == IC_OTHER)
-        printf("    %s\n", iinf[i].name);
+        printf("    %s\n", iinf[i].name), qty++;
+    printf("    total = %d\n", qty); qty = 0;
     printf("\n");
-    printf("Monsters:\n");
+    printf("+ Monsters:\n");
     for(int i=1; i<motypes; i++) 
-      printf("    %s\n", minf[i].name);
+      printf("    %s\n", minf[i].name), qty++;
+    printf("    total = %d\n", qty); qty = 0;
     printf("\n");
-    printf("Lands:\n");
-    for(int i=1; i<landtypes; i++) 
-      printf("    %s\n", linf[i].name);
+    printf("+ Lands:\n");
+    for(int i=1; i<landtypes; i++)
+      printf("    %s\n", linf[i].name), qty++;
+    printf("    total = %d\n", qty); qty = 0;
     printf("\n");
-    printf("Walls:\n");
+    printf("+ Walls:\n");
     for(int i=0; i<walltypes; i++) 
-      printf("    %s\n", winf[i].name);
+      printf("    %s\n", winf[i].name), qty++;
+    printf("    total = %d\n", qty); qty = 0;
     printf("\n");
     exit(0);
     }
@@ -252,36 +427,73 @@ int arg::readCommon() {
     printf("  -offline       - don't connect to Steam (for Steam versions)\n");
     printf("  -I ITEM n      - start with n of ITEM (activates cheat and disables ghosts)\n");
     printf("  -fix           - fix the seed\n");
-    printf("Toggles: -o0 disables, -o1 enables, -o switches");
-    printf("Not all options are documented, see hyper.cpp");
+    printf("Toggles: -o0 disables, -o1 enables, -o switches\n");
+    printf("Not all options are documented, see hyper.cpp\n");
     exit(0);
     }
   else return 1;
   return 0;
   }
 
-purehookset hooks_config;
+EX purehookset hooks_config;
 
-hookset<int()> *hooks_args;
+EX hookset<int()> hooks_args;
 
-namespace arg {
-  int curphase;
+EX map<string, pair<int, reaction_t>> *added_commands;
 
-  auto ah = addHook(hooks_args, 0, readCommon);
+EX bool delayed_start;
+
+EX namespace arg {
+
+  int read_added_commands() {
+    if(!added_commands) return 1;
+    if(added_commands->count(args())) {
+      auto& ac = (*added_commands)[args()];
+      if(ac.first == 2)
+        PHASEFROM(2);
+      if(ac.first == 3)
+        PHASE(3);
+      ac.second();
+      return 0;
+      }
+    return 1;
+    }
+  
+  EX int add_at(const string& s, int at, const reaction_t& r) {
+    if(!added_commands) added_commands = new map<string, pair<int, reaction_t>> ();
+    if(added_commands->count(s)) throw hr_exception("arg::add conflict");
+    (*added_commands)[s] = {at, r};
+    return 1;
+    }
+
+  EX int add1(const string& s, const reaction_t& r) { return add_at(s, 1, r); }
+  EX int add2(const string& s, const reaction_t& r) { return add_at(s, 2, r); }
+  EX int add3(const string& s, const reaction_t& r) { return add_at(s, 3, r); }
+
+  auto ah = addHook(hooks_args, 0, readCommon) + addHook(hooks_args, 200, read_added_commands);
   
   void read(int phase) { 
     curphase = phase;
     callhooks(hooks_config);
+    dynamicval<bool> ds(delayed_start, true);
     while(pos < isize(argument)) {
-      for(auto& h: *hooks_args) {
-        int r = h.second(); if(r == 2) return; if(r == 0) { lshift(); goto cont; }
+      int r = callhandlers(1, hooks_args);
+      switch (r) {
+        case 0: lshift(); break;
+        case 1: printf("Unknown option: %s\n", argcs()); exit(3); break;
+        case 2: return;
+        default: assert(false);
         }
-      printf("Unknown option: %s\n", argcs());
-      exit(3);
-      cont: ;
       }
     }
-  }
+EX }
 #endif
 
+#if !CAP_COMMANDLINE
+EX namespace arg {
+  EX int add1(const string& s, const reaction_t& r) { return 0; }
+  EX int add2(const string& s, const reaction_t& r) { return 0; }
+  EX int add3(const string& s, const reaction_t& r) { return 0; }
+EX }
+#endif
 }

compileunits.h

@@ -1,111 +0,0 @@
-// Usage:
-// * compile hyper.cpp with CU == 0
-// * compile init.cpp with CU == 1
-// * link them.
-// Only the parts defined in #if IN_CU(1) will be included in the second compiling.
-
-
-#ifndef CU
-#define IN_CU(x) 1
-#else
-#define IN_CU(x) (CU == x)
-#endif
-
-#include "sysconfig.h"
-#include "classes.h"
-#include "hyper.h"
-
-#define CU_INIT IN_CU(0)
-#define CU_HYPER IN_CU(0)
-
-#if IN_CU(0)
-#include "classes.cpp"
-#endif
-
-#if IN_CU(0)
-#include "shaders.cpp"
-#include "util.cpp"
-#include "hyperpoint.cpp"
-#include "patterns.cpp"
-#include "fieldpattern.cpp"
-#include "heptagon.cpp"
-#include "binary-tiling.cpp"
-#include "archimedean.cpp"
-#include "crystal.cpp"
-#include "language.cpp"
-#include "cell.cpp"
-#include "expansion.cpp"
-#include "goldberg.cpp"
-#include "irregular.cpp"
-#include "pattern2.cpp"
-#include "flags.cpp"
-#include "yendor.cpp"
-#include "complex.cpp"
-#include "savemem.cpp"
-#include "game.cpp"
-#include "orbgen.cpp"
-#include "monstergen.cpp"
-#include "landlock.cpp"
-#include "landgen.cpp"
-#include "orbs.cpp"
-#if CAP_INV
-#include "inventory.cpp"
-#else
-namespace hr { namespace inv { bool on, activating; } }
-#endif
-#include "system.cpp"
-#include "debug.cpp"
-#include "geometry.cpp"
-#include "geometry2.cpp"
-#include "polygons.cpp"
-#include "floorshapes.cpp"
-#include "mapeditor.cpp"
-#if CAP_MODEL
-#include "netgen.cpp"
-#endif
-#if CAP_TABFONT || CAP_CREATEFONT
-#include "nofont.cpp"
-#endif
-#include "basegraph.cpp"
-#include "screenshot.cpp"
-#include "renderbuffer.cpp"
-#include "help.cpp"
-#include "config.cpp"
-#include "scores.cpp"
-#include "dialogs.cpp"
-#include "menus.cpp"
-#include "geom-exp.cpp"
-#include "quit.cpp"
-#include "shmup.cpp"
-#include "conformal.cpp"
-#include "rug.cpp"
-#include "control.cpp"
-#include "hud.cpp"
-#include "hypgraph.cpp"
-#include "textures.cpp"
-#include "graph.cpp"
-#include "blizzard.cpp"
-#include "sound.cpp"
-#include "achievement.cpp"
-#include "barriers.cpp"
-#include "surface.cpp"
-#if CAP_TOUR
-#include "tour.cpp"
-#endif
-#include "commandline.cpp"
-#include "bigstuff.cpp"
-
-#if CAP_ROGUEVIZ
-#include "rogueviz.cpp"
-#endif
-
-#if CAP_DAILY
-#include "private/daily.cpp"
-#else
-namespace hr { namespace daily { bool on; } }
-#endif
-#endif
-
-#if IN_CU(1)
-#endif
-

configure.ac

@@ -1,33 +0,0 @@
-AC_PREREQ([2.68])
-AC_INIT([hyperrogue], [10.4i])
-AC_LANG([C++])
-AM_INIT_AUTOMAKE([-Wall -Werror foreign])
-AC_CONFIG_SRCDIR([hyperpoint.cpp])
-AC_PROG_CXX
-
-AC_CANONICAL_HOST
-AM_CONDITIONAL(LINUX, test ["${host_os#*linux}" != "$host_os"])
-AM_CONDITIONAL(MAC, test ["${host_os#*darwin}" != "$host_os"])
-AM_CONDITIONAL(MINGW, test ["${host_os#*mingw}" != "$host_os"])
-AM_COND_IF(LINUX, AC_DEFINE([LINUX], [1]))
-AM_COND_IF(MAC, AC_DEFINE([MAC], [1]))
-AM_COND_IF(MINGW, AC_DEFINE([WINDOWS], [1]))
-
-AC_CHECK_HEADERS([GL/gl.h OpenGL/gl.h], break, AC_MSG_RESULT([OpenGL header was not found]))
-AC_CHECK_HEADERS([GL/glew.h], [], AC_MSG_RESULT([GLEW header was not found]))
-AC_CHECK_HEADERS([png.h], [], AC_MSG_RESULT([png.h header was not found]))
-AC_CHECK_HEADERS([SDL/SDL.h], [], AC_MSG_ERROR([SDL/SDL.h header was not found]))
-AC_CHECK_HEADERS([SDL/SDL_gfxPrimitives.h], [], AC_MSG_RESULT([SDL/SDL_gfxPrimitives.h header was not found]))
-AC_CHECK_HEADERS([SDL/SDL_mixer.h], [], AC_MSG_ERROR([SDL/SDL_mixer.h header was not found]))
-AC_CHECK_HEADERS([SDL/SDL_ttf.h], [], AC_MSG_RESULT([SDL/SDL_ttf.h header was not found]))
-
-AC_SEARCH_LIBS([glBegin], [GL opengl32], [], AC_MSG_RESULT([OpenGL library was not found]))
-AC_SEARCH_LIBS([glewInit], [GLEW glew32], [], AC_MSG_RESULT([GLEW library was not found]))
-AC_SEARCH_LIBS([png_create_info_struct], [png], [], AC_MSG_RESULT([png library was not found]))
-AC_SEARCH_LIBS([SDL_SetVideoMode], [SDL], [], AC_MSG_ERROR([SDL library was not found]))
-AC_SEARCH_LIBS([aacircleColor], [SDL_gfx], [], AC_MSG_RESULT([SDL_gfx library was not found]))
-AC_SEARCH_LIBS([Mix_LoadMUS], [SDL_mixer], [], AC_MSG_ERROR([SDL_mixer library was not found]))
-AC_SEARCH_LIBS([TTF_OpenFont], [SDL_ttf], [], AC_MSG_RESULT([SDL_ttf library was not found]))
-
-AC_CONFIG_FILES([Makefile])
-AC_OUTPUT

contrib/hyperrogue.desktop

@@ -0,0 +1,8 @@
+[Desktop Entry]
+Name=HyperRogue
+Comment=Roguelike in a non-euclidean world
+Exec=hyperrogue
+Icon=hyperrogue
+Terminal=false
+Type=Application
+Categories=Game;AdventureGame;

crossbow.cpp

@@ -0,0 +1,553 @@
+// Hyperbolic Rogue
+// Copyright (C) 2011-2019 Zeno Rogue
+
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+/** \file crossbow.cpp
+ *  \brief implementation of the crossbow mode
+ */
+
+#include "hyper.h"
+
+namespace hr {
+
+EX namespace bow {
+
+#if HDR
+enum eWeapon { wBlade, wCrossbow };
+enum eCrossbowStyle { cbBull, cbGeodesic, cbGeometric };
+const string bowName[] = { "bull", "geod", "geom" };
+#endif
+
+EX eWeapon weapon;
+EX eCrossbowStyle style;
+EX bool bump_to_shoot = true;
+
+EX bool crossbow_mode() { return weapon == wCrossbow; }
+
+#if HDR
+struct bowpoint {
+  cellwalker prev, next;
+  flagtype flags;
+  bowpoint() {}
+  };
+
+struct bowscore {
+  int total;
+  cellwalker last;
+  int turns;
+  };
+#endif
+
+#if HDR
+static constexpr flagtype bpFIRST = 1;
+static constexpr flagtype bpLAST = 2;
+static constexpr flagtype bpCOPIED = 4;
+#endif
+
+EX vector<bowpoint> bowpath;
+
+EX map<cell*, vector<bowpoint>> bowpath_map;
+
+EX map<int, cell*> target_at;
+
+EX int loading_time() {
+  return style == cbBull ? 3 : 4;
+  }
+
+EX bool blocks(cell *c) {
+  if(items[itOrbAether]) return false;
+  if(isWall(c) && !among(c->wall, waMirrorWall, waMirror, waCloud) && !isNonblock(c->wall)) return true;
+  // if(c->monst && isMultitile(c->monst)) return true;
+  return false;
+  }
+
+EX int qadd(cellwalker a, cellwalker b) {
+  hassert(a.at == b.at);
+  for(int i=0; i<a.at->type; i++) if(a+i == b) return i;
+  return NODIR;
+  }
+
+int best_score_res;
+
+EX int bolt_score(cellwalker cw2) {
+  int d = cw2.at->cpdist;
+  int ntotal = 2;
+  if(inmirror(cw2.at)) cw2 = mirror::reflect(cw2);
+  if(blocks(cw2.cpeek())) return -1;
+  if(thruVine(cw2.at, cw2.cpeek())) return -1;
+  if(nonAdjacent(cw2.at, cw2.cpeek())) return -1;
+
+  if(cw2.at->monst) {
+    flagtype attackflags = AF_BOW;
+    if(items[itOrbSpeed]&1) attackflags |= AF_FAST;
+    if(items[itOrbSlaying]) attackflags |= AF_CRUSH;
+    if(items[itCurseWeakness]) attackflags |= AF_WEAK;
+    if(canAttack(cw2.cpeek(), moPlayer, cw2.at, cw2.at->monst, attackflags)) {
+      ntotal += 10000; ntotal += 1280 >> d;
+      }
+    }
+
+  for(int t=0; t<cw2.at->type; t++) {
+    cell *c1 = cw2.at->cmove(t);
+    if(!logical_adjacent(cw2.cpeek(), moPlayer, c1)) continue;
+    if(canAttack(cw2.cpeek(),moPlayer,c1,c1->monst,AF_STAB)) {
+      ntotal += 10000; ntotal += 1280 >> d;
+      }
+    }
+
+  return ntotal;
+  }
+
+EX vector<int> create_dirseq() {
+  map<cell*, bowscore> scores;
+  scores[cwt.at].total = 0;
+
+  int best_score = -1; cell* best_score_at = cwt.at;
+
+  for(cell *c: dcal) {
+    cell *c1 = target_at[c->cpdist];
+    if(c1 && c != c1) continue;
+    if(c == c1) { best_score = -1; }
+    bowscore best;
+    best.total = -1;
+    forCellIdEx(c1, i, c) if(c1->cpdist < c->cpdist && scores.count(c1)) {
+      auto& last = scores[c1];
+      auto ocw2 = cellwalker(c, i);
+      int bonus = bolt_score(ocw2);
+      if(bonus < 0) continue;
+      int ntotal = last.total + bonus;
+
+      int dir = 0;
+      if(c->cpdist > 1) {
+        dir = qadd(last.last, ocw2+wstep);
+        int d = abs(szgmod(dir, c1->type));
+        if(d != c1->type / 2) {
+          if(style == cbGeodesic) ntotal--;
+          if(style == cbBull) continue;
+          }
+        }
+      else {
+        dir = qadd(cwt, ocw2+wstep);
+        }
+      if(ntotal > best.total) {
+        best.total = ntotal;
+        best.last = ocw2;
+        best.turns = dir;
+        }
+      best.total = max(best.total, ntotal);
+      }
+    if(best.total > best_score) { best_score = best.total; best_score_at = c; }
+    if(best.total > -1) scores[c] = best;
+    }
+
+  if(best_score == -1) return {};
+
+  vector<int> dirseq = { NODIR };
+  while(best_score_at != cwt.at) { 
+    auto& at = scores[best_score_at];
+    dirseq.push_back(at.turns);
+    best_score_at = at.last.cpeek();
+    }
+  reverse(dirseq.begin(), dirseq.end());
+
+  best_score_res = best_score;
+  return dirseq;
+  }
+
+EX vector<int> create_dirseq_geometric() {
+  cell *tgt = nullptr;
+  for(auto t: target_at) tgt = t.second;
+  if(!tgt) return {};
+  hyperpoint h = tC0(currentmap->relative_matrix(tgt, cwt.at, C0));
+  transmatrix T = spintox(h);
+
+  best_score_res = 0;
+  cellwalker at = cwt;
+  vector<int> dirseq;
+  while(true) {
+    int best_i = -1;
+    ld best_y = HUGE_VAL;
+    for(int i=0; i<at.at->type; i++) {
+      cellwalker at1 = at + i;
+      if(at1.cpeek()->cpdist != at.at->cpdist + 1) continue;
+      transmatrix U = T * currentmap->adj(at.at, at1.spin);
+      hyperpoint U0 = tC0(U);
+      hyperpoint T0 = tC0(T);
+      if(U0[0] < T0[0] + 1e-6) continue;
+      ld y;
+      if(GDIM == 3) y = hypot(U0[1], U0[2]); else y = abs(U0[1]) + (U0[1] > 0 ? 1e-6 : 0);
+      if(y < best_y) { best_y = y; best_i = i; }
+      }
+    if(best_i < 0) {
+      dirseq.push_back(NODIR);
+      break;
+      }
+    at = at + best_i;
+    int bonus = bolt_score(at + wstep);
+    best_score_res += bonus;
+    dirseq.push_back(best_i);
+    if(bonus < 0) break;
+    T = T * currentmap->adj(at.at, at.spin);
+    at = at + wstep;
+    }
+
+  return dirseq;
+  }
+
+EX int create_path() {
+  auto dirseq = style == cbGeometric ? create_dirseq_geometric() : create_dirseq();
+  if(dirseq.empty()) return -1;
+
+  struct bolt {
+    cellwalker at;
+    flagtype flags;
+    bolt(cellwalker cw, flagtype f) { at = cw; flags = f; }
+    };
+
+  bowpath.clear();
+  vector<bolt> bolts = { bolt(cwt, 0) };
+  for(auto m: mirror::mirrors) bolts.emplace_back(m.second, bpCOPIED);
+
+  set<cell*> broken_mirrors;
+
+  for(auto d: dirseq) {
+    bool first = bowpath.empty();
+    vector<bolt> nbolts;
+    set<cell*> next_broken_mirrors = broken_mirrors;
+    for(auto bolt: bolts) {
+      bowpath.emplace_back();
+      auto& p = bowpath.back();
+      p.prev = bolt.at;
+      p.flags = bolt.flags;
+      if(first) p.flags |= bpFIRST;
+      if(d == NODIR || blocks(bolt.at.at)) { p.next = bolt.at; p.flags |= bpLAST; }
+      else {
+        if(inmirror(bolt.at.at) || (bolt.at.at->wall == waMirrorWall && inmirror((bolt.at+d).cpeek())))
+          bolt.at = mirror::reflect(bolt.at);
+        bolt.at += d;
+        p.next = bolt.at;
+        bolt.at += wstep;
+        if(among(bolt.at.at->wall, waCloud, waMirror) && !broken_mirrors.count(bolt.at.at)) {
+          auto &mir = mirror::mirrors;
+          vector<pair<int, cellwalker>> bmir;
+          swap(mir, bmir);
+          mirror::createHere(bolt.at, 0);
+          swap(mir, bmir);
+          for(auto b: bmir) nbolts.emplace_back(b.second, bolt.flags);
+          next_broken_mirrors.insert(bolt.at.at);
+          }
+        nbolts.push_back(bolt);
+        }
+      }
+    bolts = nbolts;
+    broken_mirrors = next_broken_mirrors;
+    }
+
+  return best_score_res;
+  }
+
+EX void clear_bowpath() {
+  bowpath_map.clear();
+  }
+
+EX void gen_bowpath_map() {
+  bowpath_map = {};
+  for(auto& b: bowpath) bowpath_map[b.next.at].push_back(b);
+  }
+
+EX bool auto_path() {
+  target_at = {};
+  target_at[1] = cwt.cpeek();
+  return create_path() >= 10000;
+  }
+
+EX bool fire_mode;
+
+EX void switch_fire_mode() {
+  if(!crossbow_mode()) { addMessage(XLAT("You fire an angry glance at your enemies.")); return; }
+  if(!fire_mode) {
+    addMessage(items[itCrossbow] ? XLAT("Note: cannot fire again yet. Turns to reload: %1.", its(items[itCrossbow])) : XLAT("Fire crossbow! Click to aim, click again to confirm."));
+    fire_mode = true;
+    clear_bowpath();
+    target_at = {};
+    }
+  else if(fire_mode) {
+    addMessage(items[itCrossbow] ? XLAT("Fire mode disabled.") : XLAT("Firing cancelled."));
+    fire_mode = false;
+    clear_bowpath();
+    }
+  }
+
+EX void add_fire(cell *c) {
+  bool emp = target_at.empty();
+  auto& t = target_at[c->cpdist];
+  if(t == c && !bow::bowpath.empty()) {
+    if(items[itCrossbow]) {
+      clear_bowpath();
+      addMessage(XLAT("Cannot fire again yet. Turns to reload: %1.", its(items[itCrossbow])));
+      fire_mode = false;
+      return;
+      }
+    clear_bowpath();
+    checked_move_issue.type = miVALID;
+    pcmove pcm;
+    pcm.checkonly = false;
+    changes.init(false);
+    addMessage(XLAT("Fire!"));
+    bool b = pcm.try_shooting(false);
+    if(!b) changes.rollback();
+    fire_mode = false;
+    }
+  else {
+    t = c;
+    if(style == cbGeometric) { target_at = {}; target_at[c->cpdist] = c; }
+    int res = create_path();
+    if(res == -1) {
+      if(!emp) {
+        target_at = {};
+        add_fire(c);
+        }
+      else {
+        addMessage(XLAT("No way to hit this place."));
+        bow::bowpath = {};
+        }
+      }
+    gen_bowpath_map();
+    }
+  }
+
+#if HDR
+enum eMouseFireMode { mfmNone, mfmPriority, mfmAlways };
+#endif
+
+EX eMouseFireMode mouse_fire_mode = mfmPriority;
+
+EX bool fire_on_mouse(cell *c) {
+  if(!crossbow_mode()) return false;
+  if(mouse_fire_mode == mfmNone) return false;
+  if(!mouseover) return false;
+  if(!mouseover->monst) return false;
+  if(shmup::on) return false;
+  if(items[itCrossbow]) {
+    if(mouse_fire_mode == mfmAlways) {
+      addMessage(XLAT("Cannot fire again yet. Turns to reload: %1.", its(items[itCrossbow])));
+      return true;
+      }
+    return false;
+    }
+  target_at = {};
+  target_at[mouseover->cpdist] = mouseover;
+  int res = create_path();
+  if(res <= 0) {
+    if(mouse_fire_mode == mfmAlways) {
+      addMessage(XLAT("Shooting impossible."));
+      return true;
+      }
+    return false;
+    }
+  gen_bowpath_map();
+  checked_move_issue.type = miVALID;
+  pcmove pcm;
+  pcm.checkonly = false;
+  changes.init(false);
+  addMessage(XLAT("Fire!"));
+  bool b = pcm.try_shooting(false);
+  if(!b) changes.rollback();
+  if(mouse_fire_mode == mfmAlways) return true;
+  return b;
+  }
+
+EX int rusalka_curses = 0;
+
+EX void shoot() {
+  flagtype attackflags = AF_BOW;
+  if(items[itOrbSpeed]&1) attackflags |= AF_FAST;
+  if(items[itOrbSlaying]) attackflags |= AF_CRUSH;
+  if(items[itCurseWeakness]) attackflags |= AF_WEAK;
+
+  vector<bowpoint> pushes;
+
+  // for achievements
+  set<eMonster> kills;
+  vector<pair<cell*, int>> healthy_dragons;
+  map<cell*, pair<int, int>> kraken_hits;
+  int dragon_hits = 0;
+  rusalka_curses = 0;
+
+  // for achievements
+  for(auto& mov: bowpath) {
+    cell *c = mov.prev.at;
+    if(c->monst == moDragonHead) {
+      bool healthy = true;
+      cell *c1 = c;
+      int qty = 0;
+      for(int i=0; i<iteration_limit; i++) {
+        if(!isDragon(c1)) break;
+        if(!c1->hitpoints) { healthy = false; break; }
+        if(c1->mondir == NODIR) break;
+        c1 = c1->move(c1->mondir);
+        qty++;
+        }
+      if(healthy) healthy_dragons.emplace_back(c, qty);
+      }
+    if(c->monst == moKrakenT && c->hitpoints) {
+      kraken_hits[kraken::head(c)].first++;
+      }
+    }
+
+  for(auto& mov: bowpath) {
+    cell *c = mov.prev.at;
+    cell *cf = mov.prev.cpeek();
+    if(!c) continue;
+    eMonster who = (mov.flags & bpCOPIED) ? moMimic : moPlayer;
+
+    if(c != cf) for(int t=0; t<cf->type; t++) {
+      cell *c1 = cf->cmove(t);
+      if(!c) continue;
+
+      bool stabthere = false;
+      if(logical_adjacent(c, moPlayer, c1)) stabthere = true;
+
+      if(stabthere && canAttack(cf,who,c1,c1->monst,AF_STAB)) {
+        hit_anything = true;
+        changes.ccell(c1);
+        eMonster m = c->monst;
+        if(attackMonster(c1, AF_STAB | AF_MSG, who))  {
+          achievement_count("STAB", 1, 0);
+          spread_plague(c1, cf, t, moPlayer);
+          produceGhost(c, m, moPlayer);
+          }
+        }
+      }
+
+    mirror::breakMirror(mov.next, -1);
+    eMonster m = c->monst;
+    if(!m || isMimic(m)) continue;
+    if(m == moKrakenH) continue;
+
+    if(!canAttack(cf, who, c, m, attackflags)) {
+      if(among(m, moSleepBull, moHerdBull)) {
+        addMessage(XLAT("%The1 is enraged!", m));
+        c->monst = moRagingBull;
+        hit_anything = true;
+        continue;
+        }
+      else {
+        pcmove pcm; pcm.mi = movei(mov.prev).rev();
+        pcm.tell_why_cannot_attack();
+        continue;
+        }
+      }
+    changes.ccell(c);
+
+    bool push = (items[itCurseWeakness] || (isStunnable(c->monst) && c->hitpoints > 1));
+    push = push && (!(mov.flags & bpLAST) && monsterPushable(c));
+
+    // for achievements
+    if(isDragon(m)) dragon_hits++;
+    if(m == moKrakenT && c->hitpoints) kraken_hits[kraken::head(c)].second++;
+
+    if(m && attackMonster(c, attackflags | AF_MSG, who)) hit_anything = true;
+
+    if(m == moRusalka) rusalka_curses++;
+
+    if(!c->monst || isAnyIvy(m)) {
+      spread_plague(cf, c, movei(mov.prev).rev().d, moPlayer);
+      produceGhost(c, m, moPlayer);
+      kills.insert(m);
+      }
+
+    if(push) pushes.push_back(mov);
+    }
+
+  while(!pushes.empty()) {
+    auto& mov = pushes.back();
+    cell *c = mov.prev.at;
+    cell *ct = mov.next.cpeek();
+    bool can_push = passable(ct, c, P_BLOW);
+    if(can_push) {
+      hit_anything = true;
+      changes.ccell(c);
+      changes.ccell(ct);
+      pushMonster(mov.next);
+      }
+    pushes.pop_back();
+    }
+
+  reverse(bowpath.begin(), bowpath.end());
+
+  // three achievements:
+  achievement_count("BOWVARIETY", kills.size(), 0);
+
+  for(auto p: healthy_dragons) {
+    cell *c = p.first;
+    if(c->monst != moDragonHead && dragon_hits >= p.second)
+      achievement_gain_once("BOWDRAGON");
+    }
+
+  for(auto kh: kraken_hits) {
+    if(kh.second.first == 3 && kh.second.second == 3) {
+      if(kraken::half_killed[kh.first]) achievement_gain_once("BOWKRAKEN");
+      else kraken::half_killed[kh.first] = true;
+      }
+    }
+
+  gen_bowpath_map();
+  }
+
+EX bool have_bow_target() {
+  dynamicval<decltype(bowpath)> bp(bowpath);
+  dynamicval<decltype(bowpath_map)> bpm(bowpath_map);
+
+  for(int i=0; i<isize(dcal); i++) {
+    cell *c = dcal[i];
+    target_at = {};
+    target_at[c->cpdist] = {c};
+
+    int res = create_path();
+    if(res == -1) continue;
+
+    checked_move_issue.type = miVALID;
+    pcmove pcm;
+    pcm.checkonly = true;
+    changes.init(true);
+    bool b = pcm.try_shooting(false);
+    changes.rollback();
+
+    if(b) return true;
+    }
+  return false;
+  }
+
+EX void showMenu() {
+  cmode = sm::SIDE | sm::MAYDARK;
+  gamescreen();
+  dialog::init(XLAT("weapon selection"));
+  add_edit(weapon);
+  if(crossbow_mode()) {
+    add_edit(style);
+    add_edit(bump_to_shoot);
+    add_edit(bow::mouse_fire_mode);
+    }
+  else dialog::addBreak(200);
+  dialog::addBack();
+  dialog::display();
+  }
+
+EX }
+
+}
+

debug.cpp

@@ -1,14 +1,33 @@
 // Hyperbolic Rogue -- debugging routines
 // Copyright (C) 2011-2018 Zeno Rogue, see 'hyper.cpp' for details
 
+/** \file debug.cpp
+ *  \brief Debugging and cheating
+ */
+
+#include "hyper.h"
 namespace hr {
 
-int steplimit = 0;
-int cstep;
+EX int steplimit = 0;
+EX int cstep;
+EX bool buggyGeneration = false;
+EX bool debug_cellnames = false;
 
-vector<cell*> buggycells;
+EX vector<cell*> buggycells;
 
-cell *pathTowards(cell *pf, cell *pt) {
+#if HDR
+template<class... T>
+void limitgen(T... args) {
+  if(steplimit) {
+    cstep++;
+    printf("%6d ", cstep);
+    printf(args...);
+    if(cstep == steplimit) buggyGeneration = true;
+    }
+  }
+#endif
+
+EX cell *pathTowards(cell *pf, cell *pt) {
 
   while(celldist(pt) > celldist(pf)) {
     if(isNeighbor(pf, pt)) return pt;
@@ -22,21 +41,14 @@ cell *pathTowards(cell *pf, cell *pt) {
   return NULL;
   }
 
-bool buggyGeneration = false;
-
 bool errorReported = false;
 
-void describeCell(cell *c) {
+EX void describeCell(cell *c) {
   if(!c) { printf("NULL\n"); return; }
-  printf("describe %p: ", c);
-  printf("%-15s", linf[c->land].name);
-  printf("%-15s", winf[c->wall].name);
-  printf("%-15s", iinf[c->item].name);
-  printf("%-15s", minf[c->monst].name);
-  printf("LP%08x", c->landparam);
-  printf("D%3d", c->mpdist);
-  printf("MON%3d", c->mondir);
-  printf("\n");
+  print(hlog, "describe ", lalign(6, c), ": ");
+  vector<cell*> nei;
+  for(int i=0; i<c->type; i++) nei.push_back(c->move(i));
+  println(hlog, ">> ", nei);
   }
 
 static int orbid = 0;
@@ -75,30 +87,23 @@ eItem randomTreasure2(int cv) {
   return best;
   }
 
-eLand cheatdest;
+EX eLand cheatdest;
 
-void cheatMoveTo(eLand l) {
+EX void cheatMoveTo(eLand l) {
   cheatdest = l;
   if(l == laCrossroads5) l = laCrossroads;
   activateSafety(l);
   cheatdest = laNone;
   }
 
-bool applyCheat(char u, cell *c = NULL) {
+struct cheatkey {
+  int key;
+  string desc;
+  reaction_t action;
+  };
 
-  if(u == 'L') {
-    do {
-      if(firstland == eLand(landtypes-1))
-        firstland = eLand(2);
-      else
-        firstland = eLand(firstland+1);
-      }
-    while(isTechnicalLand(firstland) || isCyclic(firstland));
-    specialland = firstland;
-    cheater++; addMessage(XLAT("You will now start your games in %1", firstland));
-    return true;
-    }
-  if(u == 'C') {
+vector<cheatkey> cheats = {
+  cheatkey{'C', "Hyperstone Quest", [] {
     cheater++; 
     cheatMoveTo(laCrossroads);
     addMessage(XLAT("Activated the Hyperstone Quest!"));
@@ -115,25 +120,22 @@ bool applyCheat(char u, cell *c = NULL) {
     kills[moMonkey] = qkills;
     kills[moCultist] = qkills;
     kills[moTroll] = qkills;
-    return true;
-    }
-  if(u == 'M') {
+    }},
+  cheatkey{'M', "deplete orb powers", [] {
     for(int i=0; i<ittypes; i++) 
       if(itemclass(eItem(i)) == IC_ORB) 
         items[i] = 0;
     cheater++; addMessage(XLAT("Orb power depleted!"));
-    return true;
-    }
-  if(u == 'O') {
+    }},
+  cheatkey{'O', "summon orbs", [] {
     cheater++; addMessage(XLAT("Orbs summoned!"));
     for(int i=0; i<cwt.at->type; i++) 
       if(passable(cwt.at->move(i), NULL, 0)) {
         eItem it = nextOrb();
         cwt.at->move(i)->item = it;
         }
-    return true;
-    }
-  if(u == 'F') {
+    }},
+  cheatkey{'F', "gain orb powers", [] {
     if(hardcore && !canmove) { 
       canmove = true; 
       addMessage(XLAT("Revived!"));
@@ -148,79 +150,56 @@ bool applyCheat(char u, cell *c = NULL) {
       cheater++; addMessage(XLAT("Orb power gained!"));
       canmove = true;
       }
-    return true;
-    }
-  if(u == 'D') {
-    items[itGreenStone] += 10;
-    cheater++; addMessage(XLAT("Dead orbs gained!"));
-    return true;
-    }
-  if(u == 'R'-64) buildRosemap();
-#if CAP_EDIT
-  if(u == 'A') {
+    }},
+  cheatkey{'R'-64, "advance the rose wave", buildRosemap},
+  #if CAP_EDIT
+  cheatkey{'A', "start the Map Editor", [] {
     lastexplore = turncount;
     pushScreen(mapeditor::showMapEditor);
-    return true;
-    }
-  if(u == 'A'-64) {
+    }},
+  cheatkey{'A'-64, "start the Vector Graphics Editor", [] {
     mapeditor::drawcell = mouseover ? mouseover : cwt.at;
     pushScreen(mapeditor::showDrawEditor);
-    return true;
-    }
-#elif CAP_SHOT
-  if(u == 'A') {
+    }},
+  #else
+  cheatkey{'A', "take screenshot", [] {
     pushScreen(shot::menu);
-    return true;
-    }
-#endif
-  if(u == 'T') {
+    }},
+  #endif
+  cheatkey{'T', "summon treasure", [] {
     items[randomTreasure2(10)] += 10;
     cheater++; addMessage(XLAT("Treasure gained!"));
-    return true;
-    }
-  if(u == 'T'-64) {
+    }},
+  cheatkey{'T'-64, "summon lots of treasure", [] {
     items[randomTreasure2(100)] += 100;
     cheater++; addMessage(XLAT("Lots of treasure gained!"));
-    return true;
-    }
-  if(u == 'I'-64) {
-    items[randomTreasure2(10)] += 25;
-    cheater++; addMessage(XLAT("Treasure gained!"));
-    return true;
-    }
-  if(u == 'U'-64) {
-    items[randomTreasure2(10)] += 50;
-    cheater++; addMessage(XLAT("Treasure gained!"));
-    return true;
-    }
-  if(u == 'Z') {
+    }},
+  cheatkey{'Z', "rotate the character", [] {
     if (flipplayer) {
       cwt += cwt.at->type/2;
       flipplayer = false;
       }
     cwt++;
     mirror::act(1, mirror::SPINSINGLE);
+    cwt.at->mondir++;
+    cwt.at->mondir %= cwt.at->type;
 
-    wavephase = (1+wavephase) & 7;
     if(shmup::on) shmup::pc[0]->at = Id;
-    return true;
-    }
-  if(u == 'J') {
+    }},
+  cheatkey{'J', "lose all treasure", [] {
     if(items[localTreasureType()] > 0)
       items[localTreasureType()] = 0;
     else for(int i=1; i<ittypes; i++) 
       if(itemclass(eItem(i)) == IC_TREASURE) 
         items[i] = 0;
     cheater++; addMessage(XLAT("Treasure lost!"));
-    return true;
-    }
-  if(u == 'K') {
+    }},
+  cheatkey{'K', "gain kills", [] {
     for(int i=0; i<motypes; i++) kills[i] += 10;
     kills[moPlayer] = 0;
     cheater++; addMessage(XLAT("Kills gained!"));
-    return true;
-    }
-  if(u == 'Y') {
+    }},
+  cheatkey{'Y', "unlock Orbs of Yendor", [] {
     for(auto& y: yendor::yi) {
       if(y.path[YDIST-1]->item == itKey)
         y.path[YDIST-1]->item = itNone;
@@ -228,67 +207,56 @@ bool applyCheat(char u, cell *c = NULL) {
       y.found = true;
       }
     cheater++; addMessage(XLAT("Collected the keys!"));
-    }
-  if(u == 'Y'-64) {
+    }},
+  cheatkey{'Y'-64, "gain Orb of Yendor", [] {
     yendor::collected(cwt.at);
     cheater++;
-    }
-  if(u == 'P') {
+    }},
+  cheatkey{'P', "save a Princess", [] {
     items[itSavedPrincess]++;
     princess::saved = true;
     princess::everSaved = true;
     if(inv::on && !princess::reviveAt)
       princess::reviveAt = gold(NO_LOVE);
     cheater++; addMessage(XLAT("Saved the Princess!"));
-    }
-  if(u == 'S') {
+    }},
+  cheatkey{'S', "Safety (quick save)", [] {
     canmove = true;
     cheatMoveTo(cwt.at->land);
     items[itOrbSafety] += 3;
     cheater++; addMessage(XLAT("Activated Orb of Safety!"));
-    return true;
-    }
-  if(u == 'U') {
-    canmove = true;
-    cheatMoveTo(firstland);
-    cheater++; addMessage(XLAT("Teleported to %1!", firstland));
-    return true;
-    }
-  if(u == 'W'-64) {
+    }},
+  cheatkey{'W'-64, "switch web display", [] {
     pushScreen(linepatterns::showMenu);
-    return true;
-    }
-  if(u == 'G'-64) {
+    }},
+  cheatkey{'G'-64, "switch ghost timer", [] {
     timerghost = !timerghost;
     cheater++; 
     addMessage(XLAT("turn count = %1 last exploration = %2 ghost timer = %3",
       its(turncount), its(lastexplore), ONOFF(timerghost)));
-    return true;
-    }
-  if(u == 'L'-64) {
+    }},
+  cheatkey{'G', "edit cell values", push_debug_screen},
+  cheatkey{'L'-64, "cell info", [] {
+    debug_cellnames = !debug_cellnames;
     cell *c = mouseover;
+    if(!c) return;
     describeCell(c);
-    printf("Neighbors:"); for(int i=0; i<c->type; i++) printf("%p ",  c->move(i));
-    printf("Barrier: dir=%d left=%d right=%d\n",
-      c->bardir, c->barleft, c->barright);
-    return true;
-    }
-  if(u == 'C'-64) {
-    cblind = !cblind;
-    return true;
-    }
-  if(u == 'G') {
-    push_debug_screen();
-    return true;
-    }
-  if(u == 'P'-64) 
+    }},
+  cheatkey{'P'-64, "peaceful mode", [] {
     peace::on = !peace::on;
+    }},
 #ifdef CHEAT_DISABLE_ALLOWED
-  if(u == 'D'-64) {
+  cheatkey{'D'-64, "cheat disable", [] {
     cheater = 0; autocheat = 0;
-    return true;
     }
 #endif
+  };
+
+EX bool applyCheat(char u) {
+  for(auto& ch: cheats) if(u == ch.key) {
+    ch.action();
+    return true;
+    }
   return false;
   }
 
@@ -302,7 +270,7 @@ template<class T> string dnameof2(T x, int p) {
   return s + " (" + its(x) + "/" + its(p) + ")";
   }
 
-vector<pair<cellwalker,int> > drawbugs;
+EX vector<pair<cellwalker,int> > drawbugs;
 
 bool debugmode = false;
 
@@ -312,7 +280,7 @@ int bitfield_v;
 template<class T> void bitfield_editor(int val, T setter, string help = "") {
   bitfield_v = val;
   dialog::editNumber(bitfield_v, 0, 100, 1, bitfield_v, help, "");
-  dialog::reaction = [setter] () { setter(bitfield_v); };
+  dialog::get_di().reaction = [setter] () { setter(bitfield_v); };
   }
 
 struct debugScreen {
@@ -325,10 +293,10 @@ struct debugScreen {
   
   void operator () () {
     cmode = sm::SIDE | sm::DIALOG_STRICT_X;
-    gamescreen(0);
+    gamescreen();
     getcstat = '-';
 
-    dialog::init(XLAT(show_debug_data ? "debug values" : "internal details"));
+    dialog::init(show_debug_data ? XLAT("debug values") : XLAT("internal details"));
     
     for(auto& p: drawbugs)
       drawBug(p.first, p.second);
@@ -337,9 +305,9 @@ struct debugScreen {
     if(!what && current_display->sidescreen) what = mouseover;
     
     if(what) {
-      queuepoly(gmatrix[what], shAsymmetric, 0x80808080);
-      char buf[200];
-      sprintf(buf, "%p", what);
+      #if CAP_SHAPES
+      queuepoly(gmatrix[what], cgi.shAsymmetric, 0x80808080);
+      #endif
       dialog::addSelItem("mpdist", its(what->mpdist), 'd');
       dialog::add_action([what] () { 
         bitfield_editor(what->mpdist, [what] (int i) { what->mpdist = 0; }, "generation level");        
@@ -350,11 +318,13 @@ struct debugScreen {
         "Extra value that is important in some lands. The specific meaning depends on the land."); });
       dialog::addSelItem("land param (hex)", itsh8(what->landparam), 0);
       dialog::addSelItem("land param (heat)", fts(HEAT(what)), 't');
+      dialog::addSelItem("cdata", 
+        its(getCdata(what, 0))+"/"+its(getCdata(what,1))+"/"+its(getCdata(what,2))+"/"+its(getCdata(what,3))+"/"+itsh(getBits(what)), 't');
       dialog::add_action([what] () { 
-        static double d = HEAT(what);
+        static ld d = HEAT(what);
         dialog::editNumber(d, -2, 2, 0.1, d, "landparam",
           "Extra value that is important in some lands. The specific meaning depends on the land."); 
-        dialog::reaction = [what] () { HEAT(what) = d; };
+        dialog::get_di().reaction = [what] () { HEAT(what) = d; };
         });
       dialog::addSelItem("land flags", its(what->landflags)+"/"+itsh2(what->landflags), 'f');
       dialog::add_action([what] () { 
@@ -367,30 +337,68 @@ struct debugScreen {
       dialog::addSelItem("barrier left", dnameof2(what->barleft), 0);
       dialog::addSelItem("barrier right", dnameof2(what->barright), 0);
       if(what->item == itBabyTortoise) {
-        dialog::addSelItem("baby Tortoise flags", itsh(tortoise::babymap[what]), 'B');
+        dialog::addSelItem(XLAT("baby Tortoise flags"), itsh(tortoise::babymap[what]), 'B');
         dialog::add_action([what] () {
           dialog::editNumber(tortoise::babymap[what], 0, (1<<21)-1, 1, getBits(what), "", "");
+          dialog::use_hexeditor();
           });
         }
       if(what->monst == moTortoise) {
-        dialog::addSelItem("adult Tortoise flags", itsh(tortoise::emap[what]), 'A');
+        dialog::addSelItem(XLAT("adult Tortoise flags"), itsh(tortoise::emap[what]), 'A');
         dialog::add_action([what] () {
           tortoise::emap[what] = tortoise::getb(what);
           dialog::editNumber(tortoise::emap[what], 0, (1<<21)-1, 1, getBits(what), "", "");
+          dialog::use_hexeditor();
           });
         }
+      #if CAP_COMPLEX2
+      if(dice::on(what)) {
+        dialog::addSelItem(XLAT("die shape"), dice::die_name(dice::data[what].which), 'A');
+        dialog::add_action_push([what] {
+          dialog::init("die shape");
+          char key = 'a';
+          for(auto shape: dice::die_list) {
+            dialog::addItem(dice::die_name(shape), key++);
+            dialog::add_action([what, shape] {
+              dice::data[what].which = shape;
+              dice::data[what].val = 0;
+              popScreen();
+              });
+            }
+          dialog::display();
+          });
+        dialog::addSelItem(XLAT("die face"), its(dice::data[what].val), 'B');
+        dialog::add_action([what] {
+          auto& dd = dice::data[what];
+          int maxv = shape_faces(dd.which)-1;
+          dialog::editNumber(dd.val, 0, maxv, 1, 0, XLAT("die face"), "");
+          dialog::bound_low(0);
+          dialog::bound_up(maxv);
+          });
+        dialog::addSelItem(XLAT("die direction"), its(dice::data[what].dir), 'C');
+        dialog::add_action([what] {
+          auto& dd = dice::data[what];
+          dialog::editNumber(dd.dir, 0, what->type-1, 1, dd.dir, XLAT("die direction"), "");
+          dialog::bound_low(0);
+          dialog::bound_up(what->type-1);
+          });
+        dialog::addBoolItem_action(XLAT("die mirror status"), dice::data[what].mirrored, 'D');
+        }
+      #endif
       dialog::addBreak(50);
       
       if(show_debug_data) {
-        dialog::addSelItem("pointer", buf, 0);
+        dialog::addSelItem("pointer", s0+hr::format("%p", hr::voidp(what))+"/"+index_pointer(what), 0);
         dialog::addSelItem("cpdist", its(what->cpdist), 0);
         dialog::addSelItem("celldist", its(celldist(what)), 0);
         dialog::addSelItem("celldistance", its(celldistance(cwt.at, what)), 0);
         dialog::addSelItem("pathdist", its(what->pathdist), 0);
         dialog::addSelItem("celldistAlt", eubinary ? its(celldistAlt(what)) : "--", 0);
         dialog::addSelItem("temporary", its(what->listindex), 0);
+        #if CAP_GP
         if(GOLDBERG)
           dialog::addSelItem("whirl", sprint(gp::get_local_info(what).relative), 0);
+        #endif
         #if CAP_RACING
         if(racing::on) racing::add_debug(what);
         #endif
@@ -402,13 +410,18 @@ struct debugScreen {
           "wall parameter");
           });
         dialog::addSelItem("item", dnameof(what->item), 0);
-        if(archimedean)
+        #if CAP_ARCM
+        if(arcm::in())
           dialog::addSelItem("ID", its(arcm::id_of(what->master)), 0);    
+        #endif
         dialog::addBreak(50);
         dialog::addSelItem("monster", dnameof2(what->monst, what->mondir), 'm');
         dialog::add_action([what] () {
           bitfield_editor(what->mondir, [what] (int i) { what->mondir = i; },
           "monster direction");
+          dialog::get_di().extra_options = [what] () { 
+            dialog::addBoolItem(XLAT("mirrored"), what->monmirror, 'M');
+            };
           });
         dialog::addSelItem("stuntime", its(what->stuntime), 's');
         dialog::add_action([what] () {
@@ -426,16 +439,16 @@ struct debugScreen {
         }
       }
     else {
-      dialog::addItem("click a cell to view its data", 0);
+      dialog::addItem(XLAT("click a cell to view its data"), 0);
       dialog::addBreak(1000);
       }
     dialog::addBack();
     dialog::display();
-  
-    keyhandler = [this, what] (int sym, int uni) {
+
+    keyhandler = [this] (int sym, int uni) {
       handlePanning(sym, uni);
       dialog::handleNavigation(sym, uni);
-      if(applyCheat(uni, what)) ;
+      if(applyCheat(uni)) ;
       else if(sym == PSEUDOKEY_WHEELUP || sym == PSEUDOKEY_WHEELDOWN) ;
       else if(sym == '-') debugged_cell = mouseover;
       else if(doexiton(sym, uni)) {
@@ -446,59 +459,94 @@ struct debugScreen {
     }
   };
 
-void push_debug_screen() {
+EX void push_debug_screen() {
   debugScreen ds;
   pushScreen(ds);
   }
 
-// -- cheat menu --
-
-void showCheatMenu() {
-  gamescreen(1);
+/** show the cheat menu */
+EX void showCheatMenu() {
+  cmode = sm::SIDE | sm::MAYDARK;
+  gamescreen();
   dialog::init("cheat menu");
-  dialog::addItem(XLAT("gain orb powers"), 'F');
-  dialog::addItem(XLAT("summon treasure"), 'T');
-  dialog::addItem(XLAT("summon dead orbs"), 'D');
-  dialog::addItem(XLAT("lose all treasure"), 'J');
-  dialog::addItem(XLAT("gain kills"), 'K');
-  dialog::addItem(XLAT("Hyperstone Quest"), 'C');
-  dialog::addItem(XLAT("summon orbs"), 'O');
-  dialog::addItem(XLAT("summon lots of treasure"), 'T'-64);
-  dialog::addItem(XLAT("Safety (quick save)"), 'S');
-  dialog::addItem(XLAT("Select the land ---"), 'L');
-  dialog::addItem(XLAT("--- and teleport there"), 'U');
-  dialog::addItem(XLAT("rotate the character"), 'Z');
-  dialog::addItem(XLAT("deplete orb powers"), 'M');
-  dialog::addItem(XLAT("save a Princess"), 'P');
-  dialog::addItem(XLAT("unlock Orbs of Yendor"), 'Y');
-  dialog::addItem(XLAT("gain Orb of Yendor"), 'Y'-64);
-  dialog::addItem(XLAT("switch ghost timer"), 'G'-64);
-  dialog::addItem(XLAT("switch web display"), 'W'-64);
-  dialog::addItem(XLAT("peaceful mode"), 'P'-64);
+  for(auto& ch: cheats) {
+    dialog::addItem(XLAT(ch.desc), ch.key);
+    dialog::add_action([ch] { ch.action(); popScreen(); });
+    }
   dialog::addBreak(50);
   dialog::addBack();
   dialog::display();
-  keyhandler = []   (int sym, int uni) {
-    dialog::handleNavigation(sym, uni);
-    if(uni != 0) {
-      applyCheat(uni);
-      if(uni == 'F' || uni == 'C' || uni == 'O' ||
-        uni == 'S' || uni == 'U' || uni == 'G' ||
-        uni == 'W' || uni == 'I' || uni == 'E' ||
-        uni == 'H' || uni == 'B' || uni == 'M' ||
-        uni == 'M' || uni == 'Y'-64 || uni == 'G'-64 ||
-        uni == ' ' || uni == 8 || uni == 13 ||
-        uni == SDLK_ESCAPE || uni == 'q' || uni == 'v' || sym == SDLK_ESCAPE ||
-        sym == SDLK_F10) 
-        popScreen();
-      }
-    };
   }
 
-void modalDebug(cell *c) {
-  viewctr.at = c->master;
+/** view all the monsters and items */
+EX void viewall() {
+  celllister cl(cwt.at, 20, 2000, NULL);
+  
+  vector<eMonster> all_monsters;
+  for(int i=0; i<motypes; i++) {
+    eMonster m = eMonster(i);
+    if(!isMultitile(m)) all_monsters.push_back(m);
+    }
+  
+  for(cell *c: cl.lst) {
+    if(isPlayerOn(c)) continue;
+    bool can_put_monster = true;
+    forCellEx(c2, c) if(c2->monst || isPlayerOn(c2)) can_put_monster = false;
+    if(can_put_monster) {
+      for(int k=0; k<isize(all_monsters); k++)
+        if(passable_for(all_monsters[k], c, nullptr, 0)) {
+          c->monst = all_monsters[k];
+          all_monsters[k] = all_monsters.back();
+          all_monsters.pop_back();
+          }
+      }
+    }
+
+  vector<cell*> itemcells;
+  for(cell *c: cl.lst) {
+    if(isPlayerOn(c) || c->monst || c->item) continue;
+    itemcells.push_back(c);
+    }
+  int id = 0;
+  for(int it=1; it<ittypes; it++) if(it != itBarrow) {
+    if(id >= isize(itemcells)) break;
+    itemcells[id++]->item = eItem(it);
+    }
+  }
+
+#if CAP_COMMANDLINE
+/** perform a move for the -cmove command */
+
+int cheat_move_gen = 7;
+
+void cheat_move(char c) {
+  using arg::cheat;
+  if(c >= '0' && c <= '9' && cheat_move_gen == -1) cheat_move_gen = (c - '0');
+  else if(c >= '0' && c <= '9') cheat(), cwt += (c - '0');
+  else if(c == 's') {
+    cheat();
+    cwt += wstep; 
+    playermoved = false;
+    setdist(cwt.at, cheat_move_gen, cwt.peek());
+    if(geometry_supports_cdata()) getCdata(cwt.at, 0);
+    }
+  else if(c == 'r') cheat(), cwt += rev;
+  else if(c == 'm') cheat(), cwt += wmirror;
+  else if(c == 'z') cheat(), cwt.spin = 0, cwt.mirrored = false;
+  else if(c == 'F') centering = eCentering::face, fullcenter();
+  else if(c == 'E') centering = eCentering::edge, fullcenter();
+  else if(c == 'V') centering = eCentering::vertex, fullcenter();
+  else if(c == 'a') cheat(), history::save_end();
+  else if(c == 'g') cheat_move_gen = -1;
+  else println(hlog, "unknown move command: ", c);
+  }
+#endif
+
+/** launch a debugging screen, and continue normal working only after this screen is closed */
+EX void modalDebug(cell *c) {
+  centerover = c; View = Id;
   if(noGUI) {
-    fprintf(stderr, "fatal: modalDebug called on %p without GUI\n", c);
+    fprintf(stderr, "fatal: modalDebug called on %p without GUI\n", hr::voidp(c));
     exit(1);
     }
   push_debug_screen();
@@ -508,9 +556,19 @@ void modalDebug(cell *c) {
   quitmainloop = false;
   }
 
-void raiseBuggyGeneration(cell *c, const char *s) {
+void test_distances(int max) {
+  int ok = 0, bad = 0;
+  celllister cl(cwt.at, max, 100000, NULL);
+  for(cell *c: cl.lst) {
+    bool is_ok = cl.getdist(c) == celldistance(c, cwt.at);
+    if(is_ok) ok++; else bad++;
+    }
+  println(hlog, "ok=", ok, " bad=", bad);
+  }
 
-  printf("procgen error (%p): %s\n", c, s);
+EX void raiseBuggyGeneration(cell *c, const char *s) {
+
+  printf("procgen error (%p): %s\n", hr::voidp(c), s);
   
   if(!errorReported) {
     addMessage(string("something strange happened in: ") + s);
@@ -548,15 +606,44 @@ int read_cheat_args() {
     PHASEFROM(2); cheat(); reptilecheat = true;
     }
 // cheats
-  else if(argis("-WT")) {
+  else if(argis("-g")) {
+    /* debugging mode */
+    if(curphase == 1) {
+      /* use no score file */
+      scorefile = "";
+      /* set seed for reproducible results */
+      if(!fixseed) {
+        fixseed = true; autocheat = true;
+        startseed = 1;      
+        }
+      }
+    PHASE(2);
+    /* causes problems in gdb */
+    mouseaim_sensitivity = 0;
+    /* do not any play sounds while debugging */
+    effvolume = 0;
+    musicvolume = 0;
+    }
+  else if(argis("-WS")) {
     PHASE(3);
     shift(); 
     activateSafety(readland(args()));
     cheat();
     }
+  else if(argis("-WT")) {
+    PHASE(3);
+    shift(); 
+    teleportToLand(readland(args()), false);
+    cheat();
+    }
   else if(argis("-W2")) {
     shift(); cheatdest = readland(args()); cheat();
     showstartmenu = false;
+    cheatdest_list.clear();
+    }
+  else if(argis("-W3")) {
+    shift(); cheatdest_list.push_back(readland(args())); cheat();
+    showstartmenu = false;
     }
   else if(argis("-I")) {
     PHASE(3) cheat();
@@ -573,6 +660,17 @@ int read_cheat_args() {
     PHASEFROM(2);
     shift(); vid.stereo_mode = eStereo(argi());
     }
+  else if(argis("-save-cheats")) {
+    save_cheats = true;
+    }
+  else if(argis("-cmove")) {
+    PHASE(3); shift();
+    for(char c: args()) cheat_move(c);
+    }
+  else if(argis("-ipd")) {
+    PHASEFROM(2);
+    shift_arg_formula(vid.ipd);
+    }
 #if CAP_INV
   else if(argis("-IU")) {
     PHASE(3) cheat();
@@ -587,17 +685,22 @@ int read_cheat_args() {
     inv::compute();
     }
 #endif
+#if CAP_COMPLEX2
   else if(argis("-ambush")) {
     // make all ambushes use the given number of dogs
     // example: hyper -W Hunt -IP Shield 1 -ambush 60
     PHASE(3) cheat();
-    shift(); ambushval = argi();
+    shift(); ambush::fixed_size = argi();
+    }
+#endif
+  else if(argis("-testdistances")) {
+    PHASE(3); shift(); test_distances(argi());
     }
   else if(argis("-M")) {
-    PHASE(3) cheat();
+    PHASE(3) cheat(); start_game(); if(WDIM == 3) { drawthemap(); bfs(); }
     shift(); eMonster m = readMonster(args());
     shift(); int q = argi();
-    printf("m = %s q = %d\n", dnameof(m), q);
+    printf("m = %s q = %d\n", dnameof(m).c_str(), q);
     restoreGolems(q, m, 7);
     }
   else if(argis("-MK")) {
@@ -614,29 +717,47 @@ int read_cheat_args() {
     }
   else if(argis("-each")) {
     PHASEFROM(2); start_game();
-    shift(); int q = argi(); autocheat = true;
+    shift(); int q = argi(); cheat();
     for(int i=0; i<ittypes; i++)
       if(itemclass(eItem(i)) == IC_TREASURE)
         items[i] = q;
     }
-  else if(argis("-we")) {    
+  else if(argis("-each-random")) {
+    PHASEFROM(2); start_game(); cheat();
+    for(int i=0; i<ittypes; i++)
+      if(itemclass(eItem(i)) == IC_TREASURE) {
+        items[i] = 10 + hrand(21);
+        if(i == itElemental) items[i] = 12;
+        }
+      else
+        items[i] = 0;
+    }
+  else if(argis("-viewall")) {
+    PHASE(3); start_game();
+    viewall();
+    }
+  else if(argis("-unlock-all")) {
+    cheat(); all_unlocked = true;
+    }
+  else if(argis("-wef")) {
     PHASEFROM(2);
-    shift_arg_formula(whatever, delayed_geo_reset);
+    shift(); int index = argi(); 
+    shift_arg_formula(whatever[index]);
     }
   else if(argis("-wei")) {    
     PHASEFROM(2);
-    shift(); whateveri = argi(); delayed_geo_reset();
+    shift(); int index = argi();
+    shift(); whateveri[index] = argi();
     }
-  else if(argis("-wei2")) {
-    PHASEFROM(2);
-    shift(); whateveri2 = argi(); delayed_geo_reset();
-    }
-  else if(argis("-W3")) {
+  else if(argis("-W4")) {
     shift(); top_land = readland(args()); cheat();
     showstartmenu = false;
     }
   else if(argis("-top")) {
-    PHASE(3); View = View * spin(-M_PI/2);
+    PHASE(3); View = View * spin(-90._deg);
+    }
+  else if(argis("-idv")) {
+    PHASE(3); View = Id;
     }
   else if(argis("-gencells")) {
     PHASEFROM(2); shift(); start_game();
@@ -657,7 +778,11 @@ int read_cheat_args() {
   else if(argis("-smart")) {
     PHASEFROM(2); cheat();
     vid.use_smart_range = 2;
-    shift_arg_formula(vid.smart_range_detail);
+    shift_arg_formula(WDIM == 3 ? vid.smart_range_detail_3 : vid.smart_range_detail);
+    }
+  else if(argis("-smartarea")) {
+    PHASEFROM(2); cheat();
+    shift(); vid.smart_area_based = argi();
     }
   else if(argis("-smartn")) {
     PHASEFROM(2);
@@ -668,27 +793,101 @@ int read_cheat_args() {
     PHASEFROM(2); 
     shift(); vid.cells_drawn_limit = argi();
     }
+  else if(argis("-genlimit")) {
+    PHASEFROM(2); 
+    shift(); vid.cells_generated_limit = argi();
+    }
+  else if(argis("-sight3")) {
+    PHASEFROM(2); 
+    shift_arg_formula(sightranges[geometry]);
+    }
+  else if(argis("-sloppy")) {
+    PHASEFROM(2); 
+    vid.sloppy_3d = true;
+    }
+  else if(argis("-gen3")) {
+    PHASEFROM(2); 
+    shift_arg_formula(extra_generation_distance);
+    }
   else if(argis("-quantum")) {
     cheat();
     quantum = true;
     }
+  else if(argis("-lands")) {
+    PHASEFROM(2);
+    stop_game();
+    shift(); land_structure = (eLandStructure) (argi());
+    }
   else if(argis("-fix")) {
     PHASE(1);
     fixseed = true; autocheat = true;
     }
+  else if(argis("-cellnames")) {
+    cheat(); debug_cellnames = true;
+    }
   else if(argis("-fixx")) {
     PHASE(1);
     fixseed = true; autocheat = true;
     shift(); startseed = argi();
     }
+  else if(argis("-reseed")) {
+    PHASEFROM(2);
+    shift(); shrand(argi());
+    }
   else if(argis("-steplimit")) {
     fixseed = true; autocheat = true;
     shift(); steplimit = argi();
     }
+  else if(argis("-dgl")) {
+    #if CAP_GL
+    glhr::debug_gl = true;
+    #endif
+    }
+  else if(argis("-mgen-off")) {
+    PHASEFROM(3);
+    cheat();
+    gen_wandering = false;
+    }
+  else if(argis("-canvasfloor")) {
+    shift(); canvasfloor = argi();
+    for(int i=0; i<caflEND; i++) if(appears(mapeditor::canvasFloorName(i), args()))
+      canvasfloor = i;
+    }
+  else if(argis("-keys")) {
+    shift(); string s = args();
+    bool quote = false;
+    for(char c: s)
+      if(quote) {
+        quote = false;
+        if(c == '\\') dialog::queue_key(c), quote = false;
+        else if(c >= '1' && c <= '9') dialog::queue_key(SDLK_F1 + c - '1');
+        else if(c == 'e') dialog::queue_key(SDLK_ESCAPE);
+        else if(c == 'r') dialog::queue_key(SDLK_RETURN);
+        else if(c == 't') dialog::queue_key(SDLK_TAB);
+        else if(c == 'b') dialog::queue_key(SDLK_BACKSPACE);
+        else if(c == 'R') dialog::queue_key(SDLK_RIGHT);
+        else if(c == 'L') dialog::queue_key(SDLK_LEFT);
+        else if(c == 'U') dialog::queue_key(SDLK_UP);
+        else if(c == 'D') dialog::queue_key(SDLK_DOWN);
+        else if(c == 'H') dialog::queue_key(SDLK_HOME);
+        else if(c == 'E') dialog::queue_key(SDLK_END);
+        else if(c == 'P') dialog::queue_key(SDLK_PAGEUP);
+        else if(c == 'Q') dialog::queue_key(SDLK_PAGEDOWN);
+        }
+      else if(c == '\\') quote = true;
+      else dialog::queue_key(c);
+    }
+  else if(argis("-hroll")) {
+    shift();
+    int i = argi();
+    while(i>0) i--, hrand(10);
+    }
   else if(argis("-W")) {
     PHASEFROM(2);
     shift(); 
     firstland0 = firstland = specialland = readland(args());
+    if (!landUnlocked(firstland))
+      cheat();
     stop_game_and_switch_mode(rg::nothing);
     showstartmenu = false;
     }
@@ -699,4 +898,10 @@ int read_cheat_args() {
 auto ah_cheat = addHook(hooks_args, 0, read_cheat_args);
 #endif
 
+EX bool ldebug = false;
+
+EX void breakhere() {
+  exit(1);
+  }
+
 }

devmods/3d-field-quotients.txt

@@ -0,0 +1,80 @@
+336h: D29C2418 p=3, f=3, n=10, q=5,1
+336h: 7769A558 p=5, f=25, n=650, q=50
+336h: 640FB3D4 p=7, f=7, n=28, q=14,1
+336h: C734F868 p=7, f=7, n=28, q=14,1
+336h: E3F6B7BC p=7, f=49, n=672, q=336,28,16
+336h: 885F1184 p=7, f=49, n=672, q=336,42,28,16
+
+344h: B23AF1F4 p=3, f=3, n=5, q=1
+344h: 4F9920E0 p=3, f=3, n=5, q=1
+344h: 6DBBAAA0 p=3, f=3, n=10, q=5,1
+344h: F81E97B0 p=3, f=3, n=10, q=5,1
+344h: F790CEA4 p=3, f=3, n=30, q=6,3
+344h: C95EC8B8 p=3, f=3, n=30, q=3
+344h: 16518434 p=3, f=9, n=16, q=8,4,2
+344h: 558C8ED0 p=5, f=5, n=600, q=20,25
+344h: 1EC39944 p=5, f=5, n=600, q=20,25
+344h: AF042EA8 p=5, f=25, n=2400, q=1200,600,60,40
+344h: EC29DCEC p=5, f=25, n=2600, q=1300,650,100
+344h: D26948E0 p=5, f=25, n=2600, q=1300,650,100
+
+345h: F978E264 p=3, f=3, n=30, q=6,3
+345h: 02ADCAA4 p=3, f=3, n=30, q=6,3
+345h: 7EFE8D98 p=5, f=25, n=650, q=50,25
+345h: F447F75C p=11, f=11, n=55, q=5
+345h: 58A698B8 p=19, f=19, n=285, q=15
+345h: 6FA03030 p=19, f=19, n=285, q=57,15
+
+353h: 1566EBAC p=5, f=25, n=130, q=10
+353h: 5A2E2B88 p=11, f=11, n=11, q=1
+
+354h: 58A8E850 p=5, f=5, n=2, q=1
+354h: 363D8DA4 p=11, f=11, n=22, q=11,2
+354h: 9CD5E744 p=11, f=11, n=22, q=11,2
+354h: F04BA28C p=19, f=19, n=114, q=57,6
+
+355h: AF448B14 p=5, f=5, n=1
+355h: F42F2904 p=5, f=5, n=1
+355h: 47F0C740 p=5, f=5, n=120, q=6,4
+355h: 7BAFB45C p=11, f=11, n=11, q=1
+355h: 6453A3FC p=11, f=11, n=11, q=1
+
+435h: EB201050 p=5, f=25, n=650, q=25
+435h: 65CE0C00 p=11, f=11, n=55, q=11,5
+435h: 5641E95C p=11, f=11, n=55, q=11,5
+
+436h: 235F7508 p=2, f=4, n=2, q=1
+436h: C02F2A80 p=2, f=4, n=2, q=1
+436h: DFC6B8C0 p=2, f=4, n=8, q=4,2
+436h: 4D3C8B14 p=3, f=9, n=8, q=1
+436h: FF82A214 p=5, f=25, n=650, q=50,25
+436h: 4546E270 p=5, f=25, n=650, q=25
+436h: C4884090 p=7, f=7, n=28, q=14,4,2
+436h: 5230B364 p=7, f=7, n=28, q=14,2
+436h: 2D051038 p=7, f=7, n=14, q=7,2
+436h: F0997060 p=7, f=7, n=14, q=7,2
+436h: 1D1227CC p=7, f=49, n=672, q=336,112,42,14,12
+436h: B2B4B3D4 p=7, f=49, n=672, q=336,14,12
+436h: 6C29B2A4 p=13, f=13, n=91, q=13,7
+436h: 06F4054C p=13, f=13, n=91, q=13,7
+436h: DE4912E0 p=13, f=13, n=182, q=91,13,7
+436h: 417466F0 p=13, f=13, n=182, q=91,13,7
+
+534h: 0C62E214 p=5, f=25, n=130, q=10
+534h: 72414D0C p=5, f=25, n=260, q=10
+534h: 831E2D74 p=11, f=11, n=22, q=2
+534h: 5FC4CFF0 p=11, f=11, n=22, q=2
+
+535h: DCC3CACE p=5, f=5, n=1
+535h: F78E1C56 p=5, f=5, n=1
+535h: 9EF7A9C4 p=5, f=5, n=120, q=10,8,6,4
+535h: 5254DA16 p=19, f=19, n=57, q=3
+535h: A5C8752E p=19, f=19, n=57, q=3
+
+536h: BB5AEE10 p=5, f=5, n=120, q=8,6,4
+536h: 61385498 p=5, f=5, n=2, q=1
+536h: B009EB44 p=5, f=5, n=2, q=1
+536h: 3BA5C5A4 p=5, f=25, n=130, q=10
+536h: 9FDE7B38 p=5, f=25, n=260, q=130,10
+536h: 885F1184 p=7, f=49, n=672, q=336,28,16
+

devmods/README.md

@@ -0,0 +1,4 @@
+This subdirectory contains various extra modules which are useful in development,
+but are not a part of standard HyperRogue build nor RogueViz.
+
+They can be added to a HyperRogue build e.g. with `mymake devmods/edit-shaders`.

devmods/autoplay.cpp

@@ -0,0 +1,423 @@
+// This addon plays HyperRogue by itself.
+// Well, not really -- it performs illegal moves, and it gets tons of treasure, orbs, and kills out of nowhere.
+// Useful for debugging.
+
+#include "../hyper.h"
+
+namespace hr {
+
+bool doAutoplay;
+eLand autoplayLand;
+
+namespace prairie { extern cell *enter; }
+
+bool sameland(eLand ll, eLand ln) {
+  if(ln == laBarrier || ln == laOceanWall)
+    return true;
+  if(ln == ll) return true;
+  if(isElemental(ln) && isElemental(ll)) return true;
+  if(isHaunted(ln) && isHaunted(ll)) return true;
+  return false;
+  }
+
+void randomCheat() {
+  int croll = hrand(50);
+  if (croll < 25) {
+    eItem b = (eItem) hrand(ittypes);
+    printf("Gain item: %s\n", iinf[b].name);
+    items[b] = (1 << hrand(11)) - 1;
+    items[itOrbYendor] &= 15;
+    reduceOrbPowers(); // in particlar, cancel out slaying+weakness, since the combination may confuse shadow
+  } else if (croll == 25) {
+    printf("Gain kills\n");
+    kills[hrand(motypes)] = (1 << hrand(11)) - 1;
+  } else if (croll == 26) {
+    printf("Princess soon\n");
+    princess::saved = true;
+    princess::everSaved = true;
+    items[itSavedPrincess]++;
+    items[itOrbLove] = 1;
+    items[itOrbTime] = 0;
+  } else if (croll == 27) {
+    printf("Gain allies\n");
+    forCellEx(cz, cwt.at)
+      if (!cz->monst)
+        cz->monst = pick(moMouse, moFriendlyGhost, moGolem, moTameBomberbird, moKnight);
+  } else if (croll == 28) {
+    printf("Place orbs with pickup effects\n");
+    forCellEx(cz, cwt.at)
+      if (!cz->item)
+        cz->item = pick(itOrbLife, itOrbFriend, itOrbSpeed, itOrbShield, itOrbChaos, itOrbPurity);
+  } else if (croll == 29) {
+    printf("Place fun walls\n");
+    forCellEx(cz, cwt.at)
+      if (!cz->wall && !cz->monst)
+        cz->wall = pick(waExplosiveBarrel, waBigStatue, waThumperOff, waBonfireOff, waCloud, waMirror);
+  } else if (croll == 30) {
+    cell *ct = dcal[hrand(isize(dcal))];
+    if (!isPlayerOn(ct) && !ct->monst && !ct->wall) {
+      eWall hazard = pick(waRose, waFireTrap, waMineMine, waTrapdoor, waChasm, waCavewall);
+      printf("Spam a hazard: %s\n", winf[hazard].name);
+      ct->wall = hazard;
+    }
+  } else if (croll == 31 && !memory_saving_mode) {
+    //printf("Saving memory\n");
+    //memory_saving_mode = true;
+    //save_memory();
+    //memory_saving_mode = false;
+  } else if (croll == 33) {
+    cell *ct = dcal[hrand(isize(dcal))];
+    if (!isPlayerOn(ct) && !ct->monst && !ct->wall) {
+      printf("Spam some slime\n");
+      ct->item = itNone;
+      ct->wall = hrand(2) ? waFloorA : waFloorB;
+      switch(hrand(4)) {
+        case 0: ct->monst = moSlime; break;
+        case 1: ct->item = itGreenStone; break;
+        default: ;
+      }
+    }
+  } else if (croll == 37) {
+    cell *ct = dcal[hrand(isize(dcal))];
+    if (!isPlayerOn(ct) && !ct->monst && !ct->wall) {
+      ct->monst = pick(moRagingBull, moTroll, moAcidBird, moMiner, moReptile, moVineBeast, moBug0, moBug1);
+      printf("Spam a monster: %s\n", minf[ct->monst].name);
+    }
+    // todo: dice
+  } else if (croll == 38) {
+    forCellEx(cz, cwt.at) {
+      if (cz->monst == moPrincessArmed) {
+        printf("Disarming a princess\n");
+        cz->monst = moPrincess;
+      }
+    }
+  } else if (croll == 39) {
+    //forCellEx(cz, cwt.at) {
+    //  if (!cz->monst) {
+    //    printf("Summoning an unarmed princess incorrectly\n");
+    //    cz->monst = moPrincess;
+    //    break;
+    //  }
+    //}
+  } else if (croll == 40) {
+    //forCellEx(cz, cwt.at) {
+    //  if (!cz->monst) {
+    //    printf("Summoning an armed princess incorrectly\n");
+    //    cz->monst = moPrincessArmed;
+    //    break;
+    //  }
+    //}
+  } else if (croll == 41) {
+    cell *ct = dcal[hrand(isize(dcal))];
+    if (among(ct->wall, waNone, waVinePlant, waFloorA, waFloorB, waTrapdoor, waChasm, waBigStatue)) {
+      // Set wparam on a cell where it shouldn't matter, so that if this wall is later converted
+      // to a walltype that does care by some code that assumes wparam was 0,
+      // we can find out if that causes bugs.
+      printf("Randomizing wparam on %s at %p\n", winf[ct->wall].name, (void *)ct);
+      ct->wparam = (unsigned char) hrand(256);
+    }
+  } else if (croll == 42) {
+    vid.wallmode = hrand(7);
+    printf("Set vid.wallmode to %d: %s\n", vid.wallmode, wdmodes[vid.wallmode]);
+  } else if (croll == 43) {
+    vid.monmode = hrand(4);
+    printf("Set vid.monmode to %d: %s\n", vid.monmode, mdmodes[vid.monmode]);
+  }
+}
+
+cell *cellToTarget() {
+  if (isCrossroads(cwt.at->land)) {
+    for (cell *c: dcal) {
+      if (c->land == laCamelot && c->wall == waNone) {
+        printf("Trying to teleport into Camelot\n");
+        items[itOrbTeleport] += 1;
+        return c;
+      }
+    }
+  }
+
+  if(cwt.at->land == laCamelot) {
+    int oldDist = celldistAltRelative(cwt.at);
+    if (oldDist > 3) {
+      for (cell *c: dcal) {
+        if (c->land == laCamelot) {
+          int dist = celldistAltRelative(c);
+          if (-1 <= dist && dist <= 1 && hrand(10) == 0) {
+            printf("Trying to teleport near the round table (%d to %d)\n", oldDist, dist);
+            items[itOrbTeleport] += 1;
+            return c;
+          }
+        }
+      }
+    }
+  }
+
+  return dcal[hrand(isize(dcal))];
+}
+
+void randomMove()
+{
+  // don't show warning dialogs
+  items[itWarning] = 1;
+
+  int roll = hrand(50);
+  if (roll == 0) {
+    // drop dead orb
+    bool res = movepcto(MD_DROP, 1);
+    printf("DROP: %d\n", res);
+  } else if (roll < 5) {
+    // skip turn
+    bool res = movepcto(MD_WAIT, 1);
+    printf("WAIT: %d\n", res);
+  } else if (roll < 42) {
+    // move to or attack a neighbor cell
+    int i = hrand(cwt.at->type);
+    cell *c2 = cwt.at->move(i);
+    cwt.spin = 0;
+    int d = neighborId(cwt.at, c2);
+    if (d >= 0) {
+      int subdir = (roll%2==0)?1:-1;
+      string c2info = dnameof(c2->wall) + "; " + dnameof(c2->monst) + "; " + dnameof(c2->item);
+      bool res = movepcto(d, subdir, false);
+      printf("MOVE %d [%s] sub %d: %d\n", d, c2info.c_str(), subdir, res);
+      if (!res && c2->monst) {
+        printf("clearing the monster (%s)\n", minf[c2->monst].name);
+        killMonster(c2, moNone);
+      }
+    } else {
+      printf("MOVE CONFUSED %d\n", d);
+    }
+  } else {
+    // try to use a ranged orb
+    cell *ct = cellToTarget();
+    eItem ti = targetRangedOrb(ct, roMouseForce);
+    const char *tm = iinf[ti].name;
+    printf("TARGET %p: %s\n", (void*)ct, tm);
+  }
+}
+
+void noteUnusualSituations()
+{
+  if(cwt.at->monst && !isMultitile(cwt.at->monst)) {
+    // This is possible in multiple ways
+    printf("on a non-multitile monster: %s\n", minf[cwt.at->monst].name);
+    }
+  else if(isDie(cwt.at->wall)) {
+    // This is possible with aether + teleport
+    printf("on a wall-type die: %s\n", winf[cwt.at->wall].name);
+    }
+  }
+
+bool isAnythingWrong()
+{
+  uintptr_t ienter = (uintptr_t) prairie::enter;
+  if(ienter && ienter < 100000) {
+    printf("ERROR: prairie::enter has incorrect value\n");
+    return true;
+    }
+
+  if(buggyGeneration || isize(buggycells)) {
+    println(hlog, "ERROR: buggy generation");
+    return true;
+    }
+
+  if(isIcyLand(cwt.at)) {
+    float heat = HEAT(cwt.at);
+    // Checking for extreme values as well as NaNs and infinities
+    if (!(-1e10 < heat && heat < 1e10)) {
+      printf("ERROR: Heat is out of expected range\n");
+      return true;
+      }
+    }
+
+  if (cwt.at->land == laCamelot) {
+    for(int i=0; i<isize(dcal); i++) {
+      cell *c = dcal[i];
+      if(c->land == laCamelot && celldistAltRelative(c) == 0 && c->wall != waRoundTable) {
+        printf("ERROR: The round table of camelot is interrupted by a cell of %s\n", winf[c->wall].name);
+        return true;
+        }
+      }
+    }
+
+  for(int i=0; i<isize(dcal); i++) {
+    cell *c = dcal[i];
+    (void)isChild(c, NULL);
+    if(childbug) return true;
+    if(c->land == laNone) {
+      printf("ERROR: no-land found\n");
+      return true;
+      }
+    if(c->item == itBuggy || c->item == itBuggy2) {
+      printf("ERROR: buggy item found\n");
+      return true;
+      }
+    if(!euclid && isPrincess(c->monst) && princess::getPrincessInfo(c) == nullptr) {
+      printf("ERROR: missing princess info\n");
+      return true;
+      }
+    if(dice::on(c)) {
+      if(dice::data.count(c) == 0) {
+        c->item = itBuggy;
+        printf("ERROR: missing dice::data[%p]\n", (void *)c);
+        return true;
+        }
+      else if(!dice::data[c].which) {
+        // we might get here instead if someone already tried to do data[c], which creates a new element out of nothing
+        c->item = itBuggy;
+        printf("ERROR: missing dice::data[%p].which\n", (void *)c);
+        return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+void stopIfBug()
+{
+  if(isAnythingWrong()) {
+    if(noGUI) {
+      exit(1);
+      }
+    else {
+      kills[moPlayer] = 0;
+      canmove = true;
+      doAutoplay = false;
+      }
+    }
+  }
+
+void showAutoplayStats()
+{
+  printf("cells travelled: %d\n", celldist(cwt.at));
+
+  printf("\n");
+
+  for(int i=0; i<ittypes; i++) if(items[i])
+    printf("%4dx %s\n", items[i], iinf[i].name);
+
+  printf("\n");
+
+  for(int i=1; i<motypes; i++) if(kills[i])
+    printf("%4dx %s <%d>\n", kills[i], minf[i].name, i);
+
+  printf("\n\n\n");
+  }
+
+void resetIfNeeded(int *gcount)
+{
+  if(hrand(5000) == 0 || (isGravityLand(cwt.at->land) && coastvalEdge(cwt.at) >= 100) || *gcount > 2000 || cellcount >= 20000000) {
+    printf("RESET\n");
+    *gcount = 0;
+    cellcount = 0;
+    activateSafety(autoplayLand ? autoplayLand : landlist[hrand(isize(landlist))]);
+    if (cellcount < 0) {
+      //printf("How did cellcount become negative?\n");
+      cellcount = 1;
+      }
+    }
+
+  if(cwt.at->land == laWestWall && cwt.at->landparam >= 30) {
+    printf("Safety generated\n");
+    forCellEx(c2, cwt.at) c2->item = itOrbSafety;
+    }
+  }
+
+/* auto a3 = addHook(hooks_nextland, 100, [] (eLand l) { 
+  eLand l2;
+  do { l2 = pick(laRuins, laTerracotta, laPrairie); } while(l2 == l);
+  return l2;
+  }); */
+
+void autoplay(int num_moves = 1000000000) {
+  // drawMesh();
+  // exit(0);
+
+  doAutoplay = true;
+
+  cheater = 1;
+  eLand lland = laIce;
+  eLand lland2 = laIce;
+  int lcount = 0;
+  int gcount = 0;
+  int lastgold = 0;
+  
+  // landlist = { laRuins, laTerracotta, laPrairie };
+
+  generateLandList(isLandIngame);
+
+#ifndef NOSDL
+  int lastdraw = 0;
+#endif
+  while(doAutoplay) {
+
+    if(gold() > lastgold) { 
+      lastgold = gold();
+      gcount = 0;
+      }
+    else gcount++;
+    
+    if(false && sameland(lland, cwt.at->land)) lcount++;
+    else {
+      lcount = 0; lland2 = lland; lland = cwt.at->land;
+      printf("%10dcc %5dt %5de %5d$ %5dK %5dgc %-30s H%d\n", cellcount, turncount, celldist(cwt.at), gold(), tkills(), gcount, dnameof(cwt.at->land).c_str(), hrand(1000000));
+      fflush(stdout);
+#ifndef NOSDL
+      if(int(SDL_GetTicks()) > lastdraw + 3000) {
+        lastdraw = SDL_GetTicks();
+        fullcenter();
+        msgs.clear();
+        popScreenAll();
+        drawscreen();
+        clearAnimations();
+        }
+#endif
+      //mainloop();
+      }
+
+    /* if(gcount < 500) for(int i=1; i<isize(dcal); i++) {
+      c2 = dcal[i];
+      if(lcount >= 50 && !sameland(lland, c2->land) && !sameland(lland2, c2->land)) break;
+      else if(lcount < 50 && c2->item && c2->item != itOrbSafety) break;
+      } */
+
+    randomCheat();
+    randomMove();
+    if(false) if(turncount % 5000 == 0) showAutoplayStats();
+    resetIfNeeded(&gcount);
+    noteUnusualSituations();
+    stopIfBug();
+
+    if(turncount >= num_moves) return;
+    }
+  }
+
+int readArgs() {
+  using namespace arg;
+           
+  if(0) ;
+  else if(argis("-autoplayW")) {
+    // Start in this land and reset to this land
+    PHASE(3);
+    shift();
+    autoplayLand = readland(args());
+    activateSafety(autoplayLand);
+    }
+  else if(argis("-autoplay")) {
+    PHASE(3); 
+    autoplay();
+    }
+  else if(argis("-autoplayN")) {
+    PHASE(3); 
+    shift();
+    autoplay(argi());
+    }
+
+  else return 1;
+  return 0;
+  }
+
+auto hook = addHook(hooks_args, 100, readArgs);
+
+}

devmods/edit-shaders.cpp

@@ -0,0 +1,135 @@
+// This addon is useful when debugging or tuning shaders.
+// Press F2, edit the shader files, then press F3 to see them in action.
+
+// F2: write the currently used shaders to files
+// F3: replace the currently used shaders with the content of the files
+
+// Might need some editing.
+
+#include "../hyper.h"
+
+namespace hr {
+
+string load_whole(const char *fname) {
+  char buf[1000000];
+  FILE *f = fopen(fname, "rb");
+  int n = fread(buf, 1, 1000000, f);
+  buf[n] = 0;
+  return buf;
+  }
+
+void print_shader(const char *fname, string s) {
+  FILE *f = fopen(fname, "wb");
+  int indent = 0;
+  bool linestart = true;
+  for(char c: s) {
+    if(c == ' ' && linestart) continue;
+    if(c == '\n' && linestart) continue;
+    linestart = false;
+    fputc(c, f);
+    if(c == '{') indent += 2;
+    if(c == '}') indent -= 2;
+    if(c == ';' || c == '}' || c == '{') {
+      fputc('\n', f);
+      for(int i=0; i<indent; i++) fputc(' ', f);
+      linestart = true;
+      }
+    }
+  fclose(f);
+  }
+
+bool es_handleKey(int sym, int uni) {  
+
+  using namespace glhr;
+  if(sym == SDLK_F2) {
+    glhr::be_textured();
+    current_display->set_all(0);
+    auto p = current_glprogram;
+    print_shader("devmods/current.vsh", p->_vsh);
+    print_shader("devmods/current.fsh", p->_fsh);
+    addMessage("shaders saved");
+    return true;
+    }
+
+  if(sym == SDLK_F4) {
+    println(hlog, "shader program = ", glhr::current_glprogram->_program);
+    solv_all = !solv_all;
+    println(hlog, "now solv_all = ", solv_all);
+    return true;
+    }
+
+  /*if(sym == SDLK_F5) {
+    drawthemap();
+    for(auto& p: ptds) {
+      auto s = dynamic_cast<dqi_poly*> (&*p);
+      if(!s) continue;
+      for(int i=0; i<s->cnt; i+=3) {
+        array<hyperpoint, 3> ps;
+        for(int k=0; k<3; k++) ps[k] = s->V * gltopoint((*(s->tab))[i+k]);
+        array<hyperpoint, 3> ie;
+        for(int k=0; k<3; k++) ie[k] = inverse_exp(ps[k]);
+        ld iz = 99, az = -99;
+        for(int k=0; k<3; k++) {
+          if(ie[k][2] < iz) iz = ie[k][2];
+          if(ie[k][2] > az) az = ie[k][2];
+          }
+        if(iz < 0 && az > 0)
+          println(hlog, tie(iz, az), ps);
+        }
+      }
+    
+    return true;
+    } */
+
+  if(sym == SDLK_F5) {
+    /*
+    for(ld x=1; x<30; x+=.2)
+    for(ld y=1; y<30; y+=.2)
+    for(ld z=0; z<=20.1; z+=.02) {
+      hyperpoint p = point31(x, y, z);
+      transmatrix T = rgpushxto0(p);
+      auto ie = inverse_exp(p);
+      for(ld ax=-0.2; ax<=0.21; ax+=0.2)
+      for(ld ay=-0.2; ay<=0.21; ay+=0.2)
+      for(ld az=-0.2; az<=0.21; az+=0.2) {
+        hyperpoint p1 = T * point31(ax, ay, az);
+        auto ie1 = inverse_exp(p1);
+        if(ie[2] * ie1[2] < 0 && abs(ie[2]) > .5 && abs(ie1[2]) > .5)
+          println(hlog, lalign(30, kz(p)), ": ", lalign(30, kz(ie)), " ", lalign(30, kz(p1)), ": ", lalign(30, kz(ie1)), " @ ",
+            make_tuple(sn::x_to_ix(p[0]), sn::x_to_ix(p[1]), sn::z_to_iz(p[2])));
+        }
+      }
+    */
+    return true;
+    }
+
+  if(sym == SDLK_F3 && !solv_all) {
+    glhr::be_textured();
+    current_display->set_all(0);
+    string vsh = load_whole("devmods/current.vsh");
+    string fsh = load_whole("devmods/current.fsh");
+    println(hlog, "loaded vsh:\n", vsh);
+    auto p = make_shared<glhr::GLprogram>(vsh, fsh);
+    println(hlog, "compiled program: ", p->_program);
+    
+    auto old = current_glprogram;
+    p->shader_flags = old->shader_flags;
+    
+    auto replace = [&] (shared_ptr<GLprogram>& s) {
+      if(s == old) s = p;
+      };
+    
+    for(auto& pp: compiled_programs) replace(pp.second);
+    for(auto& pp: matched_programs) replace(pp.second);
+
+    return true;
+    }
+  
+  return false;
+  }
+
+auto eshook = 
+  addHook(hooks_handleKey, 100, es_handleKey)
++ 0;
+
+}

devmods/gentrans.cpp

@@ -0,0 +1,227 @@
+#include "../hyper.h"
+#include <iostream>
+#include <thread>
+
+namespace hr {
+
+char buf[10000000];
+int bufpos;
+
+bool chk(const char *s) {
+  char *t = buf+bufpos;
+  while(*s == *t) s++, t++;
+  return *s == 0;
+  }
+
+bool eat(const char *s) {
+  bool ret = chk(s);
+  if(ret) bufpos += strlen(s);
+  return ret;
+  }
+
+char eatchar() {
+  return buf[bufpos++];
+  }
+
+set<string> seen;
+
+void check_ex(string s, string help) {
+  if(seen.count(s)) return;
+  seen.insert(s);
+  if(!translation_exists(s)) println(hlog, "S(", as_nice_cstring(s), ", ", help, ")");
+  }
+
+void check_nonliteral(string s, string fname, int line) {
+  if(seen.count(s)) return;
+  seen.insert(s);
+  string thu = "", end = "";
+  for(char c: s) if(c == '[') break; else thu += c;
+  for(char c: s) if(c == ']') end = ""; else end += c;
+  
+  if(s == "s") ;
+  else if(thu == "minetexts")
+    for(string m: minetexts) check_ex(m, s);
+  else if(thu == "dfnames")
+    for(string m: dfnames) check_ex(m, s);
+  else if(thu == "ncnames")
+    for(string m: ncnames) check_ex(m, s);
+  else if(thu == "slides" && end == ".help") ;
+    // for(auto sl: tour::slides) check_ex(sl.help);
+  else if(thu == "slides" && end == ".name") ;
+    // for(auto sl: tour::slides) check_ex(sl.name);
+  else if(end == ".menu_displayed_name") ;
+    // for(auto g: ginf) check_ex(g.menu_displayed_name);
+  else if(end == ".tiling_name") ;
+    // for(auto g: ginf) check_ex(g.tiling_name);
+  else if(end == ".name_hyperbolic")
+    for(auto md: mdinf) check_ex(md.name_hyperbolic, s);
+  else if(end == ".name_spherical")
+    for(auto md: mdinf) { if(md.name_spherical != md.name_hyperbolic) check_ex(md.name_spherical, s); }
+  else if(end == ".name_euclidean")
+    for(auto md: mdinf) { if(md.name_euclidean != md.name_hyperbolic && md.name_euclidean != md.name_hyperbolic) check_ex(md.name_euclidean, s); }
+  else if(thu == "olrdesc") ;
+  else if(thu == "wdmodes") 
+    for(string m: wdmodes) check_ex(m, s);
+  else if(thu == "axemodes") 
+    for(string m: multi::axemodes) check_ex(m, s);
+  else if(thu == "axmodes") 
+    for(string m: multi::axmodes) check_ex(m, s);
+  else if(thu == "mpnames") 
+    for(string m: texture::mpnames) check_ex(m, s);
+  else if(thu == "axemodes3") 
+    for(string m: multi::axemodes3) check_ex(m, s);
+  else if(thu == "mdmodes") 
+    for(string m: mdmodes) check_ex(m, s);
+  else if(thu == "hlmodes") 
+    for(string m: hlmodes) check_ex(m, s);
+  else if(thu == "current_filter->name") 
+    for(auto f: available_filters) check_ex(f->name, s);
+  else if(thu == "olrDescriptions")
+    for(string m: olrDescriptions) check_ex(m, s);
+  else if(thu == "shmupcmdtable") ;
+  else if(thu == "stringx") ;
+  else if(thu == "lv.msg") ; /* trust */
+  else if(thu == "opt") ; /* todo */
+  else if(thu == "menu_item_name") ; /* todo */
+  else if(s == "winf[w].help") ;
+  else if(s == "linf[l].help") ;
+  else if(s == "iinf[it].help") ;
+  else if(s == "minf[m].help") ;
+  else if(among(s, "mapeditorhelp", "patthelp", "drawhelp", "warpdesc", "hyperstone_optional", "irrhelp", "helptext", "inv::helptext", "power_help", "trollhelp2")) ; /* trust */
+  else
+    println(hlog, "// unrecognized nonliteral: ", s, " in ", fname, ":", line);
+  }
+
+void check_xlat_content(string s, string fname, int line) {
+  // println(hlog, "// xlat content found: ", s);
+  string literal = "";
+  string nonliteral = "";
+  bool in_quote = false;
+  int i = 0;
+  while(i < isize(s)) {
+    auto chk = [&] (string mname, string mvalue) {
+      if(in_quote) return false;
+      for(int k=0; k<isize(mname); k++) if(s[i+k] != mname[k]) return false;
+      literal += mvalue; i += isize(mname);
+      return true;
+      };
+    if(chk("LEADERFULL", "Steam Leaderboards")) continue;
+    if(chk("LEADER", "Steam")) continue;
+    if(chk("IMAGEEXT", IMAGEEXT)) continue;
+    if(chk("SHMUPTITLE", SHMUPTITLE)) continue;
+    if(s[i] == '"') in_quote = !in_quote;
+    else if(s[i] == '\\') {
+      i++;
+      if(s[i] == '"' || s[i] == '\'' || s[i] == '\\')  literal += s[i];
+      else if(s[i] == 'n') literal += "\n";
+      else println(hlog, "unknown escape: ", s0+s[i]);
+      }
+    else if(in_quote) literal += s[i];
+    else if(among(s[i], ' ', '\n', '\r')) ;
+    else nonliteral += s[i];
+    i++;
+    }
+  if(literal != "" && nonliteral != "") {
+    println(hlog, "// confused about: ", s, " ", fname, ":", line);
+    println(hlog, "literal = ", literal);
+    println(hlog, "nonliteral = ", nonliteral);
+    }
+  else if(nonliteral != "")
+    check_nonliteral(nonliteral, fname, line);
+  else {
+    if(seen.count(literal)) return;
+    seen.insert(literal);
+    if(!translation_exists(literal)) 
+      println(hlog, "S(", s, ", literal in ", fname, ":", line, ")");
+    }
+  }
+
+void check_file(string s) {
+  FILE *f = fopen(s.c_str(), "rt");
+  int qty = fread(buf, 1, 10000000, f);
+  buf[qty] = 0;
+  fclose(f);
+  // println(hlog, "// checking file ", s, ", ", qty, " B");
+  
+  bufpos = 0;
+  
+  bool in_xlat = false;
+  bool in_quote = false;
+  string xlat_content;
+  
+  int linenum = 0;
+  
+  while(true) {
+    if(bufpos == qty) break;
+    if(buf[bufpos] == '\n') linenum++;
+    if(!in_xlat) {
+      if(eat("XLAT(")) {
+        in_xlat = true;
+        xlat_content = "";
+        }
+      else 
+        eatchar();
+      }
+    else {
+      if(eat("\"")) {
+        xlat_content += "\"";
+        in_quote = !in_quote;
+        }
+      else if(in_quote && eat("\\")) {
+        xlat_content += "\\";
+        xlat_content += eatchar();
+        }
+      else if(!in_quote && eat("(")) {
+        println(hlog, "// found parenthesis inside XLAT: ", xlat_content, " at ", s, ":", linenum);
+        }
+      else if(!in_quote && eat("?")) {
+        println(hlog, "// found '?' inside XLAT: ", xlat_content, " at ", s, ":", linenum);
+        }
+      else if(!in_quote && (eat(")") || eat(","))) {
+        check_xlat_content(xlat_content, s, linenum);
+        in_xlat = false;
+        }
+      else
+        xlat_content += eatchar();
+      }
+    }
+  }
+
+void gentrans() {
+  DIR           *d;
+  struct dirent *dir;
+  
+  println(hlog, "\n\n// checking all the files");
+
+  d = opendir(".");
+
+  if(d) {
+    while ((dir = readdir(d)) != NULL) {
+      string s = dir->d_name;
+      if(s.size() > 4 && s.substr(s.size()-4) == ".cpp")
+        check_file(s);
+      }
+    closedir(d);
+    }
+
+  println(hlog, "\n\n// checking configurables");
+  
+  for(auto& fs: params) {
+    auto& sett = fs.second;
+    if(sett->menu_item_name_modified)
+      check_ex(sett->menu_item_name, "menu_item_name for " + sett->parameter_name);
+    check_ex(sett->help_text, "help_text for " + sett->parameter_name);
+    auto ls = dynamic_cast<list_setting*> ( (setting*) &*sett);
+    if(ls)
+      for(auto opt: ls->options) {
+        check_ex(opt.first, "option first for " + sett->parameter_name);
+        check_ex(opt.second, "option second for " + sett->parameter_name);
+        }
+    }
+  
+  exit(0);
+  }
+
+auto gtar = arg::add3("-gentrans", gentrans);
+
+}

devmods/hatter.cpp

@@ -0,0 +1,516 @@
+/**
+ * This program was used to generate the rule tables in apeirodic-hat.cpp.
+ *
+ * Some data was generated by this program itself, based on manual keyboard+mouse control.
+ * Some of minor manual control tools have been removed, but the process was as follows:
+ * 
+ * * Run with `-symbol "12,6,4" -dual -canvas 101010 -smart 1 stamplen=0` and draw the hat shape, the table output is hatcorners
+ * * Place hats into clusters as shown in the paper, obtaining the table hats[0]
+ * * Place clusters into superclusters as shown in the paper, obtaining the table hats[1]
+ * * Repeat for hats[2], hats[3], hats[4] and hats[5] (the paper does not specify precisely the coordinates to arrange the clusters; but we can multiply the previous hats by scaling factor
+ * * for an approximate, and fix manually so that it matches)
+ * * 'CON Lx' lines state the rules deduced; the rules should be the same for L1 and L2 (except the matrix codes returned by matcode), so we conjecture that this set of rules is complete
+ * * Fill the table `hatid` to declare the correspondence between L1 and L2 matrices
+ * * Run again, and we get rules (prefixed by RULE1 and RULE0)
+
+ **/
+
+#include "../rogueviz/rogueviz.h"
+
+namespace rogueviz {
+
+int toplev = 5;
+
+vector<hyperpoint> hatcorners_add;
+
+vector<hyperpoint> hatcorners[2];
+
+vector<transmatrix> hats[8];
+
+vector<int> hattype;
+
+hyperpoint pt(ld x, ld y) { return hpxy(x, y); }
+
+transmatrix rot;
+
+transmatrix sca;
+
+transmatrix U;
+
+transmatrix mt(ld a, ld b, ld c, ld d, ld e, ld f, ld g, ld h, ld i) {
+  transmatrix T = Id;
+  T[0][0] = a;
+  T[0][1] = b;
+  T[0][2] = c;
+  T[1][0] = d;
+  T[1][1] = e;
+  T[1][2] = f;
+  T[2][0] = g;
+  T[2][1] = h;
+  T[2][2] = i;
+  return T;
+  }
+
+map<string, int> hatid;
+
+void init() {
+  rot = Id;
+  hatcorners[0] = {
+   pt(-1.1160254038,1.4330127019),
+   pt(-0.0915063509,2.0245190528),
+   pt(0.2500000000,1.4330127019),
+   pt(-0.0915063509,0.8415063509),
+   pt(0.9330127019,0.2500000000),
+   pt(0.9330127019,-0.9330127019),
+   pt(0.2500000000,-0.9330127019),
+   pt(-0.0915063509,-1.5245190528),
+   pt(-1.1160254038,-0.9330127019),
+   pt(-2.1405444566,-1.5245190528),
+   pt(-2.4820508076,-0.9330127019),
+   pt(0,0),
+   pt(-1.7990381057,0.2500000000),
+   pt(-1.1160254038,0.2500000000),
+   };
+  hatcorners[0][11] = mid(hatcorners[0][10], hatcorners[0][12]);
+  hatcorners[1] = hatcorners[0];
+  for(auto& h: hatcorners[1]) h = MirrorX * h;
+  reverse(hatcorners[1].begin(), hatcorners[1].end());
+
+  hats[0] = {
+    mt(0.5000000000,-0.8660254038,-1.3660254038, -0.8660254038,-0.5000000000,-0.0000000000, 0.0000000000,0.0000000000,1.0000000000) * MirrorX,
+    mt(0.5000000000,-0.8660254038,0.6830127019, 0.8660254038,0.5000000000,1.6830127019, 0.0000000000,0.0000000000,1.0000000000),
+    mt(-1.0000000000,0.0000000000,-2.2320508076, -0.0000000000,-1.0000000000,-1.8660254038, 0.0000000000,0.0000000000,1.0000000000),
+    mt(-0.5000000000,-0.8660254038,-4.5310889132, 0.8660254038,-0.5000000000,-1.6160254038, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,-0.8660254038,-3.4150635095, 0.8660254038,0.5000000000,1.6830127019, 0.0000000000,0.0000000000,1.0000000000),
+    mt(1.0000000000,-0.0000000000,-2.0490381057, 0.0000000000,1.0000000000,3.5490381057, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,0.8660254038,0.2500000000, -0.8660254038,0.5000000000,3.2990381057, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,-0.8660254038,-5.4641016151, 0.8660254038,0.5000000000,0.5000000000, 0.0000000000,0.0000000000,1.0000000000),
+    };
+
+  hats[1] = {
+    mt(1.0000000000,0.0000000000,0.0000000000, 0.0000000000,1.0000000000,0.0000000000, 0.0000000000,0.0000000000,1.0000000000),
+    mt(-0.5000000000,0.8660254038,-0.8660254038, -0.8660254038,-0.5000000000,7.0980762114, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,0.8660254038,-5.8971143170, -0.8660254038,0.5000000000,4.4820508076, 0.0000000000,0.0000000000,1.0000000000),
+    mt(1.0000000000,-0.0000000000,-6.1471143170, 0.0000000000,1.0000000000,-1.1830127019, 0.0000000000,0.0000000000,1.0000000000),
+    mt(-0.5000000000,-0.8660254038,-4.5310889132, 0.8660254038,-0.5000000000,-3.9820508076, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,-0.8660254038,-9.5621778265, 0.8660254038,0.5000000000,-6.5980762114, 0.0000000000,0.0000000000,1.0000000000),
+    mt(1.0000000000,-0.0000000000,-14.3432667397, 0.0000000000,1.0000000000,-3.5490381057, 0.0000000000,0.0000000000,1.0000000000),
+    };
+  hattype = {7, 8, 8, 8, 8, 8, 8};
+
+  ld q7 = 1, q8 = 0;
+  ld val;
+  for(int a=0; a<100; a++) {
+    ld nq7 = q7 + q8;
+    ld nq8 = q7 * 5 + q8 * 6;
+    println(hlog, hr::format("%.20f", val = (nq7 + nq8) / (q7 + q8)));
+    q7 = nq7; q8 = nq8;
+    }
+  val = sqrt(val);
+  println(hlog, "root: ", hr::format("%.20f", val));
+  for(int a=-50; a<50; a++)
+  for(int b=1; b<50; b++)
+  for(int c=-50; c<50; c++)
+  for(int d=1; d<50; d++) {
+    ld err = abs(a*1./b + c * sqrt(1./d) - val);
+    if(err < 1e-6)
+      println(hlog, tie(a,b,c,d), " : ", err);
+    }
+  val = (3 + sqrt(5)) / 2; // scaling each axis
+
+  sca = Id; sca[0][0] = sca[1][1] = val;
+
+  hats[2] = {
+    mt(1.0000000000,0.0000000000,0.0000000000, 0.0000000000,1.0000000000,0.0000000000, 0.0000000000,0.0000000000,1.0000000000),
+    mt(-0.5000000000,0.8660254038,1.1830127025, -0.8660254038,-0.5000000000,15.3791651251, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,0.8660254038,-12.0442286339, -0.8660254038,0.5000000000,10.3971143173, 0.0000000000,0.0000000000,1.0000000000),
+    mt(1.0000000000,0.0000000000,-14.3432667399, 0.0000000000,1.0000000000,-3.5490381057, 0.0000000000,0.0000000000,1.0000000000),
+    mt(-0.5000000000,-0.8660254038,-12.7272413356, 0.8660254038,-0.5000000000,-13.4461524228, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,-0.8660254038,-25.9544826718, 0.8660254038,0.5000000000,-18.4282032304, 0.0000000000,0.0000000000,1.0000000000),
+    mt(1.0000000000,0.0000000000,-36.8826859024, 0.0000000000,1.0000000000,-9.4641016152, 0.0000000000,0.0000000000,1.0000000000),
+    };
+
+  hats[3] = {
+    mt(1.0000000000,0.0000000000,0.0000000000, 0.0000000000,1.0000000000,0.0000000000, 0.0000000000,0.0000000000,1.0000000000),
+    mt(-0.5000000000,0.8660254038,7.3301270200, -0.8660254038,-0.5000000000,37.8564064623, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,0.8660254038,-28.4365334803, -0.8660254038,0.5000000000,26.9592921447, 0.0000000000,0.0000000000,1.0000000000),
+    mt(1.0000000000,0.0000000000,-36.8826859027, 0.0000000000,1.0000000000,-9.4641016152, 0.0000000000,0.0000000000,1.0000000000),
+    mt(-0.5000000000,-0.8660254038,-33.2176223915, 0.8660254038,-0.5000000000,-39.4724318658, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,-0.8660254038,-68.9842828915, 0.8660254038,0.5000000000,-50.3695461828, 0.0000000000,0.0000000000,1.0000000000),
+    mt(1.0000000000,0.0000000000,-96.3047909683, 0.0000000000,1.0000000000,-24.8432667403, 0.0000000000,0.0000000000,1.0000000000),
+    };
+
+  hats[4] = {
+    mt(1.0000000000,0.0000000000,0.0000000000, 0.0000000000,1.0000000000,0.0000000000, 0.0000000000,0.0000000000,1.0000000000),
+    mt(-0.5000000000,0.8660254038,23.7224318656, -0.8660254038,-0.5000000000,97.0070415601, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,0.8660254038,-71.4663337016, -0.8660254038,0.5000000000,70.7307621167, 0.0000000000,0.0000000000,1.0000000000),
+    mt(1.0000000000,0.0000000000,-96.3047909682, 0.0000000000,1.0000000000,-24.8432667399, 0.0000000000,0.0000000000,1.0000000000),
+    mt(-0.5000000000,-0.8660254038,-86.4926131352, 0.8660254038,-0.5000000000,-108.0871685769, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,-0.8660254038,-181.6813787030, 0.8660254038,0.5000000000,-134.3634480195, 0.0000000000,0.0000000000,1.0000000000),
+    mt(1.0000000000,0.0000000000,-252.0316870025, 0.0000000000,1.0000000000,-65.0656986057, 0.0000000000,0.0000000000,1.0000000000),
+    };
+
+  hats[5] = {
+    mt(1.0000000000,0.0000000000,0.0000000000, 0.0000000000,1.0000000000,0.0000000000, 0.0000000000,0.0000000000,1.0000000000),
+    mt(-0.5000000000,0.8660254038,66.7522320948, -0.8660254038,-0.5000000000,251.9817055201, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,0.8660254038,-184.1634295166, -0.8660254038,0.5000000000,185.4829942043, 0.0000000000,0.0000000000,1.0000000000),
+    mt(1.0000000000,0.0000000000,-252.0316870019, 0.0000000000,1.0000000000,-65.0656986045, 0.0000000000,0.0000000000,1.0000000000),
+    mt(-0.5000000000,-0.8660254038,-225.8272043260, 0.8660254038,-0.5000000000,-287.9050992716, 0.0000000000,0.0000000000,1.0000000000),
+    mt(0.5000000000,-0.8660254038,-476.7428659331, 0.8660254038,0.5000000000,-354.4038105811, 0.0000000000,0.0000000000,1.0000000000),
+    mt(1.0000000000,0.0000000000,-659.7902700392, 0.0000000000,1.0000000000,-170.3538290768, 0.0000000000,0.0000000000,1.0000000000),
+    };
+
+  hats[6] = hats[5];
+
+  auto acs = inverse(sca);
+
+  println(hlog, "shifts:");
+  indenter ind(2);
+  for(int i=0; i<7; i++) {
+
+    transmatrix S = gpushxto0(hats[1][i] * C0) * hats[1][i];
+    // println(hlog, "S = ", kz(S));
+    transmatrix S0 = inverse(S);
+    // transmatrix S1 = S;
+
+    auto& t = hats[6][i];
+    auto& t3 = hats[5][i];
+    auto& t2 = hats[4][i];
+    auto& t1 = hats[3][i];
+
+    hyperpoint fix2 = t2 * C0 - sca * t1 * C0;
+
+    hyperpoint cfix3 = acs * fix2;
+
+    hyperpoint rfix3 = t3 * C0 - sca * t2 * C0;
+
+    t = sca * t * acs * acs * rgpushxto0(rfix3) * sca;
+
+    println(hlog, kz(rfix3-cfix3), " from ", fix2, " .. ", S0 * cfix3 - acs * fix2);
+
+    // t = t * rgpushxto0(sca * (t3 * C0 - bt3 * C0));
+    // t = t * 
+    }
+
+  hatid["R0A000L0.000"] = -1;
+  int nextid = 8;
+
+  hatid["R0A011L6.147"] = hatid["R0A014L14.343"] = nextid++;
+  hatid["R0A016L8.196"] = hatid["R0A015L22.539"] = nextid++;
+  hatid["R0A016L8.196"] = hatid["R0A015L22.539"] = nextid++;
+  hatid["R0A191L6.147"] = hatid["R0A194L14.343"] = nextid++;
+  hatid["R0A196L8.196"] = hatid["R0A195L22.539"] = nextid++;
+  hatid["R1A023L6.903"] = hatid["R1A019L15.060"] = nextid++;
+  hatid["R1A126L5.555"] = hatid["R1A131L15.741"] = nextid++;
+  hatid["R1A185L7.579"] = hatid["R1A191L21.879"] = nextid++;
+  hatid["R1A238L3.558"] = hatid["R1A232L11.654"] = nextid++;
+  hatid["R1A327L4.885"] = hatid["R1A320L10.974"] = nextid++;
+  hatid["R2A037L6.054"] = hatid["R2A025L14.053"] = nextid++;
+  hatid["R2A092L2.046"] = hatid["R2A096L3.188"] = nextid++;
+  hatid["R2A138L8.858"] = hatid["R2A145L25.101"] = nextid++;
+  hatid["R2A221L4.953"] = hatid["R2A226L12.883"] = nextid++;
+  hatid["R2A300L2.571"] = hatid["R2A279L2.571"] = nextid++;
+  hatid["R3A226L7.005"] = hatid["R3A233L16.845"] = nextid++;
+  hatid["R4A000L5.143"] = hatid["R4A339L10.197"] = nextid++;
+  hatid["R4A097L4.093"] = hatid["R4A085L4.171"] = nextid++;
+  hatid["R4A152L9.906"] = hatid["R4A156L21.728"] = nextid++;
+  hatid["R4A198L11.809"] = hatid["R4A205L27.793"] = nextid++;
+  hatid["R4A281L4.171"] = hatid["R4A286L6.625"] = nextid++;
+  hatid["R5A087L5.006"] = hatid["R5A080L5.503"] = nextid++;
+  hatid["R5A143L7.731"] = hatid["R5A139L13.041"] = nextid++;
+  hatid["R5A246L6.309"] = hatid["R5A251L9.388"] = nextid++;
+  hatid["R5A305L6.626"] = hatid["R5A311L15.426"] = nextid++;
+  hatid["R5A358L8.119"] = hatid["R5A352L19.349"] = nextid++;
+
+  println(hlog, "nextid = ", nextid);
+  };
+
+void draw_cross(hyperpoint h) {
+  transmatrix T = rgpushxto0(h);
+  shiftmatrix sId = shiftless(Id);
+  for(int i=0; i<12; i++)
+    queueline(sId * T * C0, sId * T * xspinpush0(30._deg * i, 0.1), 0xFFFFFFFF);
+  }
+
+void draw_shape(transmatrix T, vector<hyperpoint> sh, color_t lc, color_t fc) {
+  for(hyperpoint h: sh) curvepoint(h);
+  curvepoint(sh[0]);
+  queuecurve(shiftless(Id) * T, lc, fc, PPR::LINE);
+  }
+
+/*
+void draw_superhat(transmatrix T, const vector<transmatrix>& ms, int q, color_t lc, color_t fc) {
+  for(auto& m: ms)
+    draw_shape(T * m, hatcorners, lc, fc);
+  }
+*/
+
+hyperpoint sh;
+
+color_t coltables[8] = { 0xFF000080, 0x00FF0080, 0x0000FF80, 0xFFFF0080, 0xFF00FF80, 0x00FFFF80, 0xFFFFFF80, 0x4080C080 };
+
+vector<int> curlabel;
+
+ld ldist = 9999;
+
+hyperpoint hfound, hfound1;
+
+int connection_mode = 0;
+
+int found_pairs, found_pairs_swap;
+
+using pthash = int;
+
+pthash makehash(hyperpoint h) {
+  return int(floor(h[0] * 10 + .31)) + int(floor(h[1] * 10 + .31)) * 10000;
+  }
+
+map<pair<pthash, pthash>, vector<int> > seen_edges;
+
+string name(int x) { return s0 + char('A' + x); }
+
+string matcode(transmatrix T) {
+  vector<ld> res(3);
+  hyperpoint h = kz(T * C0);
+
+  transmatrix S = gpushxto0(T * C0) * T;
+  ld alpha = atan2(S * xpush0(1)) / degree;
+  int ialpha = gmod(floor(alpha + .5), 360);
+
+  int hangle = gmod(floor(atan2(h) / degree + .3), 360);
+
+  h[2] = ialpha/60;
+  swap(h[1], h[2]); swap(h[0], h[1]);
+  // return lalign(0, h);
+
+  return hr::format("R%dA%03dL%.3f", ialpha/60, hangle, hypot_d(2, h));
+  }
+
+int ghatid(string s) {
+  if(hatid.count(s)) return hatid[s];
+  return -999;
+  }
+
+void edge_connect(vector<int> l1, vector<int> l2) {
+  transmatrix T1 = Id;
+  transmatrix T2 = Id;
+  transmatrix W = Id;
+  int idx = 0;
+  for(int i=toplev; i>0; i--) {
+    T1 = T1 * hats[i][l1[idx]];
+    T2 = T2 * hats[i][l2[idx]];
+    transmatrix W1 = inverse(T1) * T2;
+    if(!eqmatrix(W1, Id))
+      println(hlog, "CON L", i, " ", matcode(W1), " :: ", matcode(W), " ", tie(l1[idx], l2[idx]), " REV ", matcode(inverse(W1)));
+    if(i == 1) println(hlog, "RULE1 {", l1[idx], ", ", l2[idx], ", ", ghatid(matcode(W1)), ", ", ghatid(matcode(W)), ", ", ghatid(matcode(inverse(W1))), "},");
+    W = W1;
+    idx++;
+    }
+
+  println(hlog, "CON L0 ", make_pair(make_pair(l1[idx], name(l1[idx+1])), make_pair(l2[idx], name(l2[idx+1]))), " :: ", matcode(W));
+  println(hlog, "RULE0 {", l1[idx], ", ", l1[idx+1], ", ", l2[idx], ", ", l2[idx+1], ", ", ghatid(matcode(W)), "},");
+  }
+
+vector<pair<hyperpoint, hyperpoint> > extedges;
+
+void edge_label(vector<int>& lbl, hyperpoint a, hyperpoint b) {
+  auto ha = makehash(a);
+  auto hb = makehash(b);
+
+  if(connection_mode >= 2) return;
+
+  if(connection_mode == 1) {
+    if(seen_edges.count({ha, hb})) {
+      extedges.emplace_back(a, b);
+      /* vid.linewidth *= 10;
+      queueline(shiftless(Id) * a, shiftless(Id) * b, 0xFF00FF80);
+      vid.linewidth /= 10;
+      */
+      }
+    return;
+    }
+
+  if(seen_edges.count({hb, ha})) {
+    edge_connect(lbl, seen_edges[{hb, ha}]);
+    edge_connect(seen_edges[{hb, ha}], lbl);
+    seen_edges.erase({hb, ha});
+    found_pairs++;
+    return;
+    }
+  if(seen_edges.count({ha, hb})) {
+    println(hlog, "CON ", lbl, " TO ", seen_edges[{hb, ha}], " SWAP");
+    seen_edges.erase({ha, hb});
+    found_pairs_swap++;
+    return;
+    }
+  seen_edges[{ha, hb}] = lbl;
+  }
+
+void point_label(vector<int>& lbl, hyperpoint h) {
+  if(lbl == curlabel) draw_cross(h);
+  ld dist = hdist(unshift(mouseh), h);
+  if(dist < ldist) {
+    ldist = dist;
+    curlabel = lbl;
+    hfound = h;
+    println(hlog, "found: ", lbl, " at: ", dist);
+    }
+  }
+
+void draw_superhat_label(transmatrix T, const vector<transmatrix>& ms, int q, color_t lc, color_t fc, vector<int>& label) {
+  for(int i=0; i<q; i++) {
+    auto& hc = hatcorners[i == 0];
+    for(int j=0; j<isize(hc); j++) {
+      
+      label.push_back(i);
+      label.push_back(j);
+      point_label(label, T * ms[i] * hc[j]);
+
+      edge_label(label, T * ms[i] * hc[j], T * ms[i] * hc[(j+1)%isize(hc)]);
+      label.pop_back();
+      label.pop_back();
+      }
+    }
+  for(int i=0; i<q; i++) {
+    auto& hc = hatcorners[i == 0];
+    draw_shape(T * ms[i], hc, lc, fc);
+    }
+  }
+
+void draw_recurse_label(transmatrix T, int levs, int t, color_t col, vector<int>& label) {
+  if(levs == 0) {
+    draw_superhat_label(T, hats[0], t, 0xFFFFFFFF, col, label);
+    return;
+    }
+
+  if(connection_mode == 2 && levs == toplev-1) {
+   int eid = 0;
+   for(auto e: extedges) {
+     queueline(shiftless(Id) * T * e.first, shiftless(Id) * T * e.second, col);
+     label.push_back(eid++);
+     point_label(label, T * e.first);
+     label.pop_back();
+     }
+   return;
+   }
+
+  transmatrix scap = Id;
+  for(int i=1; i<levs; i++) scap = scap * sca;
+  scap = inverse(scap);
+
+  for(int i=0; i<t-1; i++) {
+    auto col1 = col;
+    if(col == 0) col1 = coltables[i];
+    label.push_back(i);
+    draw_recurse_label(T * hats[levs][i], levs-1, hattype[i], col1, label);
+    label.pop_back();
+    }
+  }
+
+int next_hattype = 7;
+
+void hatframe() {
+  if(isize(hatcorners_add) >= 2) draw_shape(Id, hatcorners_add, 0xFF0000FF, 0xFF000080);
+
+  transmatrix B = rgpushxto0( unshift(ggmatrix(cwt.at)) * C0 );
+
+  vector<int> glabel;
+
+  draw_recurse_label(B, toplev, 8, 0, glabel);
+  if(connection_mode == 0) {
+    println(hlog, "CON found = ", found_pairs, " swap = ", found_pairs_swap, " not found = ", isize(seen_edges));
+    // seen_edges.clear(); found_pairs = 0;
+    connection_mode = 1;
+    }
+  else if(connection_mode == 1) {
+    connection_mode = 2;
+    toplev++;
+    }
+
+  draw_cross(C0);
+  }
+
+string writematrix(transmatrix T) {
+  return hr::format("mt(%.10f,%.10f,%.10f, %.10f,%.10f,%.10f, %.10f,%.10f,%.10f)",
+    T[0][0], 
+    T[0][1], 
+    T[0][2], 
+    T[1][0], 
+    T[1][1], 
+    T[1][2], 
+    T[2][0], 
+    T[2][1], 
+    T[2][2]
+    );
+  }
+
+void hatter() {
+  cmode = sm::NORMAL | sm::CENTER | sm::PANNING;
+  clearMessages();
+  dialog::init();
+  gamescreen();
+
+  shiftpoint s = mapeditor::full_mouseh();
+  sh = unshift(s);
+
+  dialog::add_key_action('a', [] {
+    hatcorners_add.push_back(sh);
+    println(hlog, "hatcorners = {");
+    for(auto h: hatcorners_add) println(hlog, hr::format("  pt(%.10f,%.10f),", h[0], h[1]));
+    println(hlog, "  }");
+    });
+
+  /* dialog::add_key_action('b', [] {
+    if(hats.empty()) return;
+    hats.pop_back();
+    hattype.pop_back();
+    }); */
+
+  dialog::add_key_action('[', [] {
+    // hyperpoint h = currentmap->get_corner(cwt.at, 0);
+    // rot = rot * gpushxto0(h);
+    rot = rot * spin(60._deg);
+    // rot = rot * rgpushxto0(h);
+    });
+
+  dialog::add_key_action(']', [] {
+    // hyperpoint h = currentmap->get_corner(cwt.at, 0);
+    // rot = rot * gpushxto0(h);
+    rot = MirrorX * rot;
+    // rot = rot * rgpushxto0(h);
+    });
+
+  dialog::add_key_action('7', [] { next_hattype = 7; });
+  dialog::add_key_action('8', [] { next_hattype = 8; });
+
+  dialog::add_key_action('f', [] { hfound1 = hfound; });
+  dialog::add_key_action('b', [] { 
+    int id = curlabel[0];
+    hats[toplev][id] = rgpushxto0(hfound1 - hfound) * hats[toplev][id];
+
+    println(hlog, "hats[", toplev, "] = {");
+      for(auto h: hats[toplev]) println(hlog, "  ", writematrix(h), ",");
+      println(hlog, "  }");
+    });
+
+  dialog::add_key_action('q', [] {
+    exit(0);
+    });
+
+  dialog::add_key_action('g', [] {
+    ldist = 9999;
+    });
+
+  keyhandler = [] (int sym, int uni) { dialog::handleNavigation(sym, uni); };
+  }
+
+void enable_hatter() {
+  init();
+  mapeditor::snapping = true;
+  rv_hook(hooks_frame, 100, hatframe);
+  pushScreen(hatter);
+  }
+  
+auto hathook = arg::add3("-hatter", enable_hatter);
+
+}

devmods/honeycomb-rule-generator.cpp

@@ -0,0 +1,559 @@
+/**
+
+Honeycomb data generator. See rulegen.sh
+
+This algorithm works as follows:
+
+- We use a DFS-like algorithm to identify all the required states. To tell whether two cells
+  c1 and c2 are in the same state, we compute its generate_ext_nei -- the same generate_ext_nei
+  is the same state. To compute generate_ext_nei(c), we list all cells vertex-adjacent to c,
+  and for each c' in this list, we compute FV(c')-FV(c), where FV is the distance from
+  some central tile. It is crucial to identify the directions in unique way (in 2D we can simply
+  use clockwise order, in 3D it is more difficult) -- we do this by using a regular pattern
+  (see get_id).
+  
+  After all states are identified, we construct the tree of states -- every non-root state is
+  attached to the first neighbor (according to the direction order) which has smaller FV.
+  For non-tree directions, we construct a path going through nodes with smaller values of FV --
+  this guarantees termination of the algorithm in amortized time O(1).
+
+*/
+
+#include "zlib.h"
+#include "../hyper.h"
+
+namespace hr {
+
+int exh;
+
+map<string, map<string,int> > rules;
+
+/** \brief distance from the center */
+#define FV master->fiftyval
+
+/** \brief change i into a string containing a displayable character */
+auto dis = [] (int i, char init='a') { return s0 + char(init + i); };
+
+bool optimize_344 = false;
+
+/** \brief we use a regular pattern to make sure that the directions are identified consistently.
+    In {5,3,5} we can just use the Seifert-Weber space for this identification; otherwise,
+    we use the field pattern. */
+    
+int get_id(cell *c) { 
+  if(geometry == gSpace535) return 0;
+  if(optimize_344 && geometry == gSpace344) {
+    /* we use the 'pattern from crystal' */
+    /* but it is mod 4, mod 2 is enough for us */
+    int res = 0;
+    int fv = c->master->fieldval;
+    for(int i=0; i<4; i++) {
+      res = 2 * res + (fv&1);
+      fv >>= 2;
+      }
+    return res;
+    }
+  return c->master->fieldval;
+  }
+
+/** \brief aux function for find_path which limits path length 
+ *  the rule is that we make some moves which decrease FV, then we make some moves which increase FV
+ */
+
+string find_path(cell *x, cell *y, int steps) {
+  if(x->FV != y->FV) {
+    println(hlog, x, y, " steps=", steps, " d=", x->FV, " vs ", y->FV);
+    exit(3);
+    }
+  if(x == y) return "";
+  if(steps == 0) return "?";
+  for(int i=0; i<S7; i++)
+    if(x->move(i) && x->move(i)->FV < x->FV)
+      for(int j=0; j<S7; j++)
+        if(y->move(j) && y->move(j)->FV < y->FV) {
+          string ch = find_path(x->move(i), y->move(j), steps-1);
+          if(ch == "?") continue;
+          return dis(i) + ch + dis(y->c.spin(j));
+          }
+  return "?";
+  }
+
+/** \brief aux function for find_path which limits path length 
+ *  the rule is that we keep to a fixed FV-level (this works better in {x,x,3})
+ */
+
+string find_path_side(cell *x, cell *y, int steps) {
+  if(x->FV != y->FV) {
+    println(hlog, x, y, " steps=", steps, " d=", x->FV, " vs ", y->FV);
+    exit(3);
+    }
+  if(x == y) return "";
+  if(steps == 0) return "?";
+  for(int i=0; i<S7; i++)
+    if(x->move(i) && x->move(i)->FV == x->FV) {
+      string ch = find_path_side(x->move(i), y, steps-1);
+      if(ch == "?") continue;
+      return dis(i) + ch;
+      }
+  return "?";
+  }
+
+/** \brief find the sequence of moves we need to take to get from y to x (x and y must be the same fv-level)
+ *  return '?' if nothing found
+ */
+
+string find_path(cell *x, cell *y) {
+  if(x == y) return "";
+
+  if(geometry == gSpace353) {
+    static int max_steps = -1;
+    
+    for(int steps=0; steps<5; steps++) {
+      string f = find_path_side(x, y, steps);
+      if(f != "?") {
+        if(steps > max_steps) {
+          println(hlog, "found a sidepath with ", max_steps = steps, " steps");
+          }
+        return f;
+        }
+      }
+    
+    if(max_steps < 10) {
+      max_steps = 10;
+      println(hlog, "failed to find_path_side");
+      }
+    }
+  
+  for(int steps=0;; steps++) {
+    string f = find_path(x, y, steps);
+    if(f != "?") return f;
+    }
+  }
+
+/** a map of all the cells vertex-adjacent to c */
+struct ext_nei_rules_t {
+  vector<int> from, dir, original;
+  };
+
+/** ext_nei_rules_t need to be created only once for each get_id */
+map<int, ext_nei_rules_t> ext_nei_rules;
+
+/** aux recursive function of construct_rules: the compact variant */
+void listnear_compact(cell *c, ext_nei_rules_t& e, const transmatrix& T, int id, set<cell*>& visi) {
+  visi.insert(c);
+  int a = 0, b = 0;
+  for(int i=0; i<S7; i++) {
+    bool ok = false;
+    transmatrix U = T * currentmap->adj(c, i);
+    for(auto v: cgi.heptshape->vertices_only) for(auto w: cgi.heptshape->vertices_only)
+      if(hdist(v, U*w) < 1e-3) ok = true;
+    if(!ok) continue;
+    cell *c1 = c->cmove(i);
+    int id1 = isize(e.from);
+    e.from.push_back(id);
+    e.dir.push_back(i);
+    a++;
+    e.original.push_back(!visi.count(c1));
+    if(e.original.back()) {
+      b++;
+      listnear_compact(c1, e, U, id1, visi);
+      }
+    }
+  }
+
+/** aux recursive function of construct_rules: the maxdist variant */
+void listnear_exh(cell *c, ext_nei_rules_t& e, int maxdist) {
+  map<cell*, int> dist;
+  map<cell*, int> origdir;
+  vector<cell*> lst;
+
+  println(hlog, "called listnear_exh for: ", c);
+  
+  auto enqueue = [&] (cell *c, int d, int od) {
+    if(dist.count(c)) return;
+    dist[c] = d;
+    origdir[c] = od;
+    lst.push_back(c);
+    };
+  
+  enqueue(c, 0, -1);
+  for(int k=0; k<isize(lst); k++) {
+    cell *ca = lst[k];
+    int di = dist[ca] + 1;
+    int odi = origdir[ca];
+    for(int i=0; i<S7; i++) {
+      if(odi >= 0 && cgi.heptshape->dirdist[i][odi] != 1) continue;
+      cell *c1 = ca->cmove(i);
+      e.from.push_back(k);
+      e.dir.push_back(i);
+      e.original.push_back(!dist.count(c1));
+      if(e.original.back() && di < maxdist) 
+        enqueue(c1, di, ca->c.spin(i));
+      }
+    }
+  }
+
+/** \brief create ext_nei_rules_t for the given c */
+void construct_rules(cell *c, ext_nei_rules_t& e) {
+  e.from = {-1};
+  e.dir = {-1};
+  e.original = {1};
+  if(!exh) {
+    set<cell*> visi;
+    listnear_compact(c, e, Id, 0, visi);
+    }
+  else {
+    listnear_exh(c, e, exh);
+    }
+  int orgc = 0;
+  for(auto i: e.original) orgc += i;
+  println(hlog, "id ", get_id(c), " list length = ", isize(e.original), " original = ", orgc);
+  }
+
+/** \brief we learn that a and b are connected -- make sure that their FV's match */
+void fix_dist(cell *a, cell *b) {
+  if(a->FV > b->FV+1) {
+    a->FV = b->FV+1;
+    forCellEx(c, a) fix_dist(a, c);
+    }
+  if(b->FV > a->FV+1) {
+    b->FV = a->FV+1;
+    forCellEx(c, b) fix_dist(b, c);
+    }  
+  }
+
+/** \brief compute ext_nei_rules_t for the given cell, and make it into a string form; also do fix_dist */
+
+string generate_ext_nei(cell *c) {
+  int fv = get_id(c);
+  auto& e = ext_nei_rules[fv];
+  if(e.from.empty()) construct_rules(c, e);
+  vector<cell*> ext_nei = {c};
+  for(int i=1; i<isize(e.from); i++) {
+    cell *last = ext_nei[e.from[i]];
+    cell *next = last->cmove(e.dir[i]);
+    fix_dist(last, next);
+    ext_nei.push_back(next);
+    }
+  string res;
+  for(int i=0; i<isize(e.from); i++) if(e.original[i]) res += char('L' + ext_nei[i]->FV - c->FV);
+  return its(fv) + ":" + res;
+  }
+
+/** cells become 'candidates' before their generate_ext_nei is checked in order to let them become states */
+set<cell*> candidates;
+vector<cell*> candidates_list;
+
+/** the state ID for a given string returned by generate_ext_nei */
+map<string, int> id_of;
+
+/** cell representing the given state ID */
+vector<cell*> rep_of;
+
+/** current number of states */
+int number_states = 0;
+
+/** \brief for state s, child_rules[s][i] is -1 if i-th neighbor not a child; otherwise, the state index of that neighbor */
+vector<vector<int> > child_rules;
+
+/** parent direction for every state */
+vector<int> parent_list;
+
+/** \brief if child_rules[s][i] is -1, the rules to get to that neighbor */
+vector<vector<string> > side_rules;
+
+void add_candidate(cell *c) {
+  if(candidates.count(c)) return;
+  candidates.insert(c);
+  candidates_list.push_back(c);
+  }
+
+bool single_origin = false;
+
+/** the main function */
+void test_canonical(string fname) {
+  stop_game();
+  reg3::reg3_rule_available = false;
+  fieldpattern::use_rule_fp = true;
+  fieldpattern::use_quotient_fp = true;
+  start_game();
+
+  int qc = reg3::quotient_count();
+  
+  vector<cell*> c0;
+  
+  if(optimize_344 && geometry == gSpace344) qc = 16;
+  
+  /* we start from a 'center' in every get_id-type */
+  if(single_origin) c0 = {cwt.at};
+  else if(geometry == gSpace535) {
+    c0.resize(qc, cwt.at);
+    }
+  else {
+    for(int fv=0; fv<qc; fv++) {
+      cell *c = cwt.at;
+      /* 100 to ensure that the FV-spheres around candidates do not interact */
+      for(int i=0; i<100 || get_id(c) != fv; i++) c = c->cmove(hrand(S7));
+      c->FV = 0;
+      c0.push_back(c);
+      }
+    }
+
+  for(cell* c: c0) add_candidate(c);
+
+  vector<int> empty(S7);
+  for(auto& e: empty) e = -1;
+  println(hlog, "empty = ", empty);
+  
+  /** generate candidate_list using a BFS-like algorithm, starting from c0 */
+  
+  for(int i=0; i<isize(candidates_list); i++) {
+    cell *c = candidates_list[i];
+    string s = generate_ext_nei(c);
+    if(!id_of.count(s)) {
+      // println(hlog, "found candidate for: ", s);
+      id_of[s] = number_states++;
+      rep_of.push_back(c);
+      for(int i=0; i<S7; i++) add_candidate(c->cmove(i));
+      }
+    }
+  
+  child_rules.resize(number_states, empty);
+  
+  parent_list.resize(number_states);
+  
+  println(hlog, "found ", its(number_states), " states");
+  
+  /** generate child_rules */
+
+  for(int i=0; i<number_states; i++) {
+    cell *c = rep_of[i];
+
+    string st = generate_ext_nei(c);
+    if(!id_of.count(st) || id_of[st] != i) {
+      println(hlog, "error: ext_nei changed");
+      }
+
+    for(int a=0; a<S7; a++) {
+      cell *c1 = c->move(a);
+      if(c1->FV < c->FV) parent_list[i] = a;
+      if(c1->FV <= c->FV) continue;
+      for(int b=0; b<S7; b++) {
+        cell *c2 = c1->move(b);
+        if(c2->FV != c->FV) continue;
+        if(c2 == c) {
+          string st = generate_ext_nei(c1);
+          if(!id_of.count(st)) {
+            println(hlog, "error: new state generated while generating child_rules");
+            }
+          child_rules[i][a] = id_of[st];
+          }
+        break;
+        }
+      continue;
+      }
+    }
+
+  if(true) {
+  
+    /* minimize the automaton */
+
+    // println(hlog, "original rules: ", child_rules);
+    fflush(stdout);
+
+    vector<int> ih(number_states, 0);
+    
+    int lqids = 0;
+    
+    for(int a=0; a<100; a++) {
+      set<vector<int>> found;
+      vector<vector<int>> v(number_states);
+      map<vector<int>, int> ids;
+      for(int i=0; i<number_states; i++) {
+        vector<int> res(S7+1);
+        for(int d=0; d<S7; d++) res[d] = (child_rules[i][d] != -1) ? ih[child_rules[i][d]] : -1;
+        res[S7] = parent_list[i];
+        v[i] = res;
+        found.insert(res);
+        }
+      int qids = 0;
+      for(auto hash: found) ids[hash] = qids++;
+      println(hlog, "minimization step: ", qids, " states");
+      if(qids == lqids) break;
+      lqids = qids;
+      for(int i=0; i<number_states; i++)
+        ih[i] = ids[v[i]];
+      }
+    
+    println(hlog, "reduced states to = ", lqids);
+    vector<vector<int> > new_child_rules;
+    new_child_rules.resize(lqids, empty);  
+    for(int i=0; i<number_states; i++) {
+      int j = ih[i];
+      for(int d=0; d<S7; d++) {
+        int cid = child_rules[i][d];
+        new_child_rules[j][d] = cid == -1 ? -1 : ih[cid];
+        }
+      }
+    child_rules = new_child_rules;
+    number_states = lqids;
+    for(auto& p: id_of) p.second = ih[p.second];
+    println(hlog, "rehashed");
+    fflush(stdout);
+    }
+
+  // for(auto& a: child_rules) for(auto i:a) print(hlog, i, ",");
+  println(hlog);
+  
+  /* generate side rules */
+  side_rules.resize(number_states);
+  for(auto& s: side_rules) s.resize(S7);
+
+  for(int i=0; i<isize(candidates_list); i++) {
+    cell *c = candidates_list[i];
+    string s = generate_ext_nei(c);
+    if(!id_of.count(s)) println(hlog, "error: MISSING");
+    int id = id_of[s];
+    
+    cell *cpar = nullptr;
+    int a0;
+
+    for(int a=0; a<S7; a++) {
+      cell *c1 = c->move(a);
+      if(!c1) continue;
+      if(c1->FV < c->FV && !cpar) cpar = c1, a0 = a;      
+      }
+    
+    for(int a=0; a<S7; a++) {
+      cell *c1 = c->move(a);
+      if(!c1) continue;
+      bool is_child = false;
+      cell* c2 = nullptr;
+      int dir = 0;
+      
+      if(c1->FV >= c->FV) {
+        for(int b=0; b<S7; b++) {
+          c2 = c1->move(b);
+          if(!c2) continue;
+          if(c2->FV >= c1->FV) continue;
+          dir = c1->c.spin(b);
+          break;
+          }
+        }
+
+      is_child = (c2 == c);
+      bool was_child = child_rules[id][a] >= 0;
+
+      if(is_child ^ was_child) {
+        println(hlog, "id=", id, " a=", a);
+        println(hlog, "is_child = ", is_child);
+        println(hlog, "was_child = ", was_child);
+        println(hlog, "c fv = ", c->FV);
+        println(hlog, "c1 fv = ", c1->FV, " [", a, "]");
+        if(c2 == nullptr) { println(hlog, "c2 missing"); }
+        else
+          println(hlog, "c2 fv = ", c2->FV, " [", c2->c.spin(dir), "]");
+        println(hlog, c, "->", c1, "->", c2);
+        fflush(stdout);
+        
+        cell *r = rep_of[id];
+        println(hlog, r, " at ", r->FV);
+        cell *r1 = r->move(a);
+        if(!r1) { println(hlog, "error: r1 missing"); continue; }
+        println(hlog, r1, " at ", r1->FV);
+        for(int a=0; a<S7; a++) if(r1->move(a)) println(hlog, a, ":", r1->move(a), " at ", r1->move(a)->FV);
+        fflush(stdout);
+        exit(3);
+        }
+      
+      if(is_child) continue;
+      
+      string solu;
+      
+      if(c1->FV < c->FV)
+        solu = dis(a0, 'A') + find_path(cpar, c1);
+      else if(c1->FV == c->FV)
+        solu = dis(a0, 'A') + find_path(cpar, c2) + dis(dir);
+      else 
+        solu = find_path(c, c2) + dis(dir);
+      
+      auto& sr = side_rules[id][a];
+      
+      if(sr != "" && sr != solu) {
+        println(hlog, "conflict: ", solu, " vs ", sr, " FV = ", c->FV, " vs ", c1->FV);
+        if(isize(sr) < isize(solu)) continue;
+        }
+
+      sr = solu;
+      
+      continue;
+      }
+    }
+
+  // println(hlog, side_rules);
+  
+  string side_data;
+  for(auto& a: side_rules) for(auto&b :a) if(b != "") side_data += b + ",";
+  println(hlog, side_data);
+  
+  vector<short> data;
+  for(auto& a: child_rules) for(auto i:a) data.push_back(i);  
+
+  shstream ss;
+  
+  auto& fp = currfp;
+  hwrite_fpattern(ss, fp);
+
+  qc = isize(c0);
+  vector<int> root(qc, 0);
+  for(int i=0; i<qc; i++) root[i] = id_of[generate_ext_nei(c0[i])];
+  println(hlog, "root = ", root);
+
+  hwrite(ss, root);
+  
+  println(hlog, "copy data");
+  hwrite(ss, data);
+  println(hlog, "copy side_data");
+  hwrite(ss, side_data);
+  
+  println(hlog, "compress_string");
+  string s = compress_string(ss.s);
+  
+  fhstream of(fname, "wb");
+  print(of, s);
+  }
+
+auto fqhook = 
+  addHook(hooks_args, 100, [] {
+  using namespace arg;
+           
+  if(0) ;
+  else if(argis("-extra-verification")) {
+    reg3::extra_verification++;
+    }
+  else if(argis("-exh")) {
+    shift(); exh = argi();
+    }
+  else if(argis("-no-rule")) {
+    reg3::reg3_rule_available = false;
+    }
+  else if(argis("-other-rule")) {
+    reg3::reg3_rule_available = true;
+    shift(); reg3::other_rule = args();    
+    }
+  else if(argis("-urf")) {
+    cheat(); fieldpattern::use_rule_fp = true;
+    }
+  else if(argis("-uqf")) {
+    cheat(); fieldpattern::use_quotient_fp = true;
+    }
+  else if(argis("-gen-rule")) {
+    shift(); test_canonical(args());
+    }
+  else return 1;
+  return 0;
+  });
+
+}
+  
+// 1 + 12 + 30 + 20 = 55

devmods/knuth-bendix.cpp

@@ -0,0 +1,594 @@
+#include "../hyper.h"
+#include <fstream>
+#include <semaphore.h>
+
+namespace hr {
+
+namespace rulegen {
+bool set_general(const string& s);
+}
+
+struct symbol {
+  unsigned char sid;
+  unsigned char eid;
+  bool operator < (const symbol s1) const { return (int16_t&) (*this) < (int16_t&) s1; } 
+  bool operator == (const symbol s1) const { return (int16_t&) (*this) == (int16_t&) s1; } 
+  bool operator != (const symbol s1) const { return (int16_t&) (*this) != (int16_t&) s1; } 
+  };
+
+using seq = vector<symbol>;
+
+void block(symbol& s) {
+  s.sid ^= 128;
+  }
+
+void unblock(symbol& s) {
+  s.sid ^= 128;
+  }
+
+bool is_blocked(symbol& s) {
+  return s.sid & 128;
+  }
+
+void print(hstream& hs, symbol s) {
+  print(hs, "[", int(s.sid), ":", int(s.eid), "]");
+  }
+
+bool reversed;
+
+bool lexless(const seq& a, const seq& b) {
+  int al = isize(a);
+  int bl = isize(b);
+  if(al != bl) return al < bl;
+  if(reversed) {
+    for(int i=al-1; i>=0; i--) if(a[i].eid < 120 && a[i] != b[i]) return a[i] < b[i];
+    return a.back() < b.back();
+    }
+  else {
+    return a < b;
+    }
+  }
+
+struct lexless_comparator {
+    bool operator()(const seq& a, const seq& b) const { return lexless(a, b); }
+};
+
+map<seq, seq, lexless_comparator> rules;
+
+seq sub(const seq& s, int a, int l) {
+  seq result;
+  for(int i=0; i<l; i++) result.push_back(s[a+i]);
+  return result;
+  }
+
+seq cat(const seq& a, const seq& b) {
+  seq result;
+  for(auto e: a) result.push_back(e);
+  for(auto e: b) result.push_back(e);
+  return result;
+  }
+
+void catto(seq& a, const seq& b) {
+  a.reserve(a.size() + b.size());
+  for(auto e: b) a.push_back(e);
+  }
+
+void catto_sub(seq& a, const seq& b, int pos, int len) {
+  a.reserve(a.size() + len);
+  for(int i=0; i<len; i++) a.push_back(b[pos+i]);
+  }
+
+int max_rule_length;
+
+set<pair<seq, seq>> rules_checked;
+
+queue<pair<seq, seq>> rulequeue;
+
+void enqueue_rule(seq l, seq r) {
+  rulequeue.emplace(l, r);
+  }
+
+cellwalker trace(cellwalker cw, const seq& sq, bool debug) {
+  for(auto sym: sq) {
+    if(shvid(cw.at) != sym.sid) println(hlog, "error: wrong type");
+    if(debug) println(hlog, "at: ", cw);
+    cw += sym.eid;
+    cw += wstep;
+    cw -= cw.spin % arb::current.shapes[shvid(cw.at)].cycle_length;
+    }
+  return cw;
+  }
+
+cell *get_sample(int sid) {
+  celllister cl(currentmap->gamestart(), 20, 100000, nullptr);
+  for(cell *c: cl.lst) if(shvid(c) == sid) return c;
+  println(hlog, "sample not found of ", sid);
+  exit(1);
+  }
+
+string verify_rule(const pair<seq, seq>& rule, bool debug = false) {
+  cell *cstart = get_sample(rule.first[0].sid);
+  cellwalker cw(cstart);
+  cellwalker cw1 = trace(cw, rule.first, debug);
+  cellwalker cw2 = trace(cw, rule.second, debug);
+  return cw1 == cw2 ? "OK" : lalign(0, "FAIL ", cw1, " VS ", cw2);
+  }
+
+int add_rule(seq l, seq r) {
+  indenter ind(2);
+  if(l == r) return 0;
+  if(lexless(l, r)) swap(l, r);
+  
+  again:
+  
+  if(!rules.count(l)) {
+    // println(hlog, "rule added: ", l, " -> ", r, " verify: ", verify_rule({l, r}));
+    rules[l] = r;
+    return 1;
+    }
+  else if(rules[l] == r) return 0;
+  else if(lexless(r, rules[l])) {
+    l = rules[l];
+    goto again;
+    }
+  else {
+    // println(hlog, "rule simplified: ", l, " -> ", r);
+    auto x = rules[l];
+    x = r;
+    l = x;
+    goto again;
+    }
+  }
+
+symbol gen_symbol(int sid, int eid) {
+  symbol sym;
+  sym.sid = sid;
+  sym.eid = eid;
+  return sym;
+  }
+
+bool include_rotations = false;
+
+void prepare_rules() {
+  auto& ac = arb::current;
+  int N = isize(ac.shapes);
+  
+  /* move and back and move */
+  if(!include_rotations) for(int i=0; i<N; i++) {
+    auto& sh = ac.shapes[i];
+    int K = sh.size();
+    for(int k=0; k<K; k++)
+    for(int l=0; l<K; l++) {
+      seq sq, sq1;
+      sq.push_back(gen_symbol(i, k));
+      auto con = sh.connections[k % sh.cycle_length];
+      auto& sh1 = ac.shapes[con.sid];
+      con.eid %= sh1.cycle_length;
+      sq.push_back(gen_symbol(con.sid, con.eid));
+      sq.push_back(gen_symbol(i, l));
+      int k1 = k / sh.cycle_length * sh.cycle_length;
+      // if(k1) 
+      sq1.push_back(gen_symbol(i, (k1 + l) % K));
+      enqueue_rule(sq, sq1);
+      }
+    }
+
+  /* move and back -> nothing or rotate */
+  if(include_rotations) for(int i=0; i<N; i++) {
+    auto& sh = ac.shapes[i];
+    int K = sh.size();
+    for(int k=0; k<K; k++) {
+      seq sq, sq1;
+      sq.push_back(gen_symbol(i, k));
+      auto con = sh.connections[k % sh.cycle_length];
+      auto& sh1 = ac.shapes[con.sid];
+      con.eid %= sh1.cycle_length;
+      sq.push_back(gen_symbol(con.sid, con.eid));
+      int k1 = k / sh.cycle_length * sh.cycle_length;
+      if(k1) sq1.push_back(gen_symbol(i, 120 + k1));
+      if(k1) sq1.push_back(gen_symbol(255, 255));
+      if(lexless(sq, sq1)) swap(sq, sq1);
+      enqueue_rule(sq, sq1);
+      }
+    }
+
+  /* rotate + move -> move */
+  if(include_rotations) for(int i=0; i<N; i++) {
+    auto& sh = ac.shapes[i];
+    int K = sh.size();
+    int C = sh.cycle_length;
+    for(int k=C; k<K; k+=C) 
+    for(int l=0; l<K; l++) {
+      seq sq, sq1;
+      sq.push_back(gen_symbol(i, 120+k));
+      sq.push_back(gen_symbol(255, 255));
+      sq.push_back(gen_symbol(i, l));
+      sq1.push_back(gen_symbol(i, (k+l) % K));
+      if(lexless(sq, sq1)) swap(sq, sq1);
+      enqueue_rule(sq, sq1);
+      }
+    }
+  
+  /* cycle a vertex */
+  for(int i=0; i<N; i++) {
+    auto& sh = ac.shapes[i];
+    for(int j=0; j<sh.cycle_length; j++) {
+      int val = sh.vertex_valence[j]; // (j+1) % sh.cycle_length];
+      int ai = i, aj = j;
+      seq sq;
+      // cellwalker cw(get_sample(i), j);
+      // auto cw0 = cw;
+      for(int v=0; v<val; v++) {
+        // println(hlog, "at: ", cw);
+        /*
+        cw++;
+        cw += wstep;
+        */
+        auto& ash = ac.shapes[ai];
+        aj += 1;
+        aj %= ash.size();
+        sq.push_back(gen_symbol(ai, aj));
+        auto co = ash.connections[aj % ash.cycle_length];
+        ai = co.sid;
+        aj = co.eid;
+        aj %= ac.shapes[ai].cycle_length;
+        }
+      // println(hlog, "finish at: ", cw, " from: ", cw0);
+      aj %= sh.cycle_length;
+      if(i != ai || j != aj /* || cw != cw0 */) { println(hlog, "bad cycling!"); return; }
+      enqueue_rule(sq, {});
+      }
+    }
+  
+  for(auto r: rules) println(hlog, r);
+  }
+
+void final_rules() {
+  auto& ac = arb::current;
+  int N = isize(ac.shapes);
+  for(int i=0; i<N; i++) {
+    auto& sh = ac.shapes[i];
+    int K = sh.size();
+    int C = sh.cycle_length;
+    for(int k=0; k<K; k++)
+    for(int l=0; l<K; l+=C) {
+      seq sq, sq1;
+      sq.push_back(gen_symbol(i, k));
+      auto con = sh.connections[k % sh.cycle_length];
+      auto& sh1 = ac.shapes[con.sid];
+      con.eid %= sh1.cycle_length;
+      sq.push_back(gen_symbol(con.sid, con.eid));
+      sq.push_back(gen_symbol(i, 120 + l));
+      int k1 = k / sh.cycle_length * sh.cycle_length;
+      // if(k1) 
+      sq1.push_back(gen_symbol(i, 120 + (k1 + l) % K));
+      enqueue_rule(sq, sq1);
+      }
+    }
+  }
+
+/* the substring of s starting at pos equals needle */
+
+bool sub_at(const seq& s, int pos, const seq& needle) {
+  for(int i=0; i<isize(needle); i++)
+    if(s[i+pos] != needle[i])
+      return false;
+  return true;
+  }
+
+/* the suffix of s1 of length len, and the prefix of s2 of length len, agree */
+bool suf_pref_agree(const seq& s1, const seq& s2, int len) {
+  for(int i=0; i<len; i++)
+    if(s1[isize(s1)-len+i] != s2[i])
+      return false;
+  return true;
+  }
+
+bool is_reducible(const seq& s, const pair<seq, seq>& r, seq& result) {  
+  int rl = isize(r.first);
+  int sl = isize(s);
+  for(int i=0; i<=sl-rl; i++)
+    if(sub_at(s, i, r.first)) {
+      result = sub(s, 0, i);
+      catto(result, r.second);
+      catto_sub(result, s, i+rl, sl-rl-i);
+      return true;
+      }
+  return false;
+  }
+
+void find_critical(const pair<seq,seq>& p, const pair<seq,seq>& q) {
+  int pl = isize(p.first);
+  int ql = isize(q.first);
+  for(int i=1; i<pl && i < ql; i++)
+    if(suf_pref_agree(p.first, q.first, i)) {
+      seq nleft = sub(p.first, 0, pl-i);
+      catto(nleft, q.second);
+      seq nright = p.second;
+      catto_sub(nright, q.first, i, ql-i);
+      enqueue_rule(nleft, nright);
+      }
+ }
+
+void handle_rule(const pair<seq, seq>& nr) {
+  auto& lh = nr.first;
+  auto& rh = nr.second;
+
+  for(auto& r: rules) {
+    seq res;
+    if(is_reducible(lh, r, res)) {
+      enqueue_rule(res, rh);
+      return;
+      }
+    if(is_reducible(rh, r, res)) {
+      enqueue_rule(lh, res);
+      return;
+      }
+    }
+  
+  vector<seq> to_erase;
+
+  for(auto& r: rules) {
+    seq res;
+    if(is_reducible(r.first, nr, res)) {
+      to_erase.push_back(r.first);
+      enqueue_rule(res, r.second);
+      }
+    if(is_reducible(rh, r, res)) {
+      to_erase.push_back(r.first);
+      enqueue_rule(r.first, res);
+      }
+    }
+  
+  for(auto s: to_erase) rules.erase(s);
+  
+  for(auto& r: rules) {
+    find_critical(r, nr);
+    find_critical(nr, r);
+    }
+  
+  rules[nr.first] = nr.second;
+  }
+
+int kb_result;
+double total_time;
+
+int main_loop(int timelimit = 5, int lenlimit = 300) {
+  
+  clock_t start = clock();
+  while(!rulequeue.empty()) {
+    if(clock() > start + timelimit * CLOCKS_PER_SEC) return 1;
+    auto p = rulequeue.front();
+    rulequeue.pop();
+    if(p.first == p.second) continue;
+    if(lexless(p.first, p.second)) swap(p.first, p.second);
+    if(rules_checked.count(p)) continue;
+    rules_checked.insert(p);
+    int len = p.first.size() + p.second.size();
+    if(len > max_rule_length) max_rule_length = len;
+    if(len > lenlimit) return 2;
+    handle_rule(p);
+    }
+  
+  println(hlog, "finished in ", (clock() - start) * 1. / CLOCKS_PER_SEC);
+  
+  return 0;  
+  }
+
+void test_knuth_bendix() {
+  rules.clear();
+  rulequeue = {};
+  rules_checked.clear();
+  max_rule_length = 0;
+  start_game();
+  
+  prepare_rules();
+  
+  clock_t total_start = clock();
+  println(hlog, "total_start = ", total_start * 1. / CLOCKS_PER_SEC);
+  
+  kb_result = main_loop(10);
+  
+  println(hlog, "after first phase = ", clock() * 1. / CLOCKS_PER_SEC);
+
+  if(kb_result == 0) {
+
+    println(hlog, "intermediate rules:");
+    for(auto s: rules) println(hlog, s.first, " => ", s.second);
+
+    final_rules();
+    kb_result = main_loop(50, 999999);
+    if(kb_result) kb_result += 2;
+    }
+  
+  println(hlog, "after second phase = ", clock() * 1. / CLOCKS_PER_SEC);
+
+  total_time = (clock() - total_start) * 1. / CLOCKS_PER_SEC;
+  }
+
+bool is_end_reducible(const seq& s1) {
+  for(auto r: rules)
+    if(isize(s1) >= isize(r.first) && sub(s1, isize(s1)-isize(r.first), isize(r.first)) == r.first)
+      return true;
+  return false;
+  }
+
+int count_tree_states() {
+  set<seq> all_prefixes;
+  for(auto r: rules) {
+    auto left = r.first;
+    for(int i=0; i<isize(left); i++) {
+      seq prefix = sub(left, 0, i);
+      seq s = prefix;
+      s.emplace_back(gen_symbol(left[i].eid, 120));
+      if(!is_end_reducible(s)) 
+        all_prefixes.emplace(prefix);
+      }
+    }
+  all_prefixes.erase(seq{});
+  for(auto x: all_prefixes)
+  println(hlog, x);
+  return isize(all_prefixes) + isize(arb::current.shapes);  
+  }
+
+bool forked = false;
+int max_children = 7;
+
+void test_all(string setname) {
+  floorshapes_level = 1;
+  vector<string> filenames;
+  std::ifstream is("devmods/rulegen-tests/"+setname+".lst");
+  string s;
+  while(getline(is, s)) {
+    while(s != "" && s[0] == ' ')  s = s.substr(1);
+    if(s != "" && s[0] != '#') filenames.push_back(s);
+    }
+
+  println(hlog, "CSV;kbres;Tp;kbrules;tree;maxlen;file");
+  
+  int children = 0;
+
+  sem_t sem;
+  if(forked) sem_init(&sem, true, 1);
+  fflush(stdout);
+
+  for(const string& s: filenames) {  
+
+    if(forked) {
+      int pid;
+      if(children >= max_children) { 
+        wait(&pid); children--; 
+        }
+      if((pid = fork())) children++;
+      else goto doit;
+      continue;
+      }
+
+    doit:
+
+    if(rulegen::set_general(s)) {
+
+      if(!arb::in()) try {
+        arb::convert::convert();
+        arb::convert::activate();
+        }
+      catch(hr_exception& e) {
+        println(hlog, "CSV; failed to convert ", s);
+        return;
+        }
+      // println(hlog, "will call test_knuth_bendix");
+      test_knuth_bendix();
+      // println(hlog, "after test_knuth_bendix");
+      if(forked) sem_wait(&sem);
+      println(hlog, "CSV;",kb_result,";", total_time, ";", isize(rules), ";", kb_result == 0 ? count_tree_states() : 0, ";", max_rule_length, ";", s);
+      if(forked) sem_post(&sem);
+      fflush(stdout);
+      }
+    if(forked) exit(0);
+    }
+
+  while(children) { int pid; wait(&pid); children--; }
+  if(forked) sem_destroy(&sem);
+  }
+
+void kb_merge() {
+  vector<string> filenames;
+  std::ifstream is("devmods/rulegen-tests/all.lst");
+  string s;
+  while(getline(is, s)) {
+    while(s != "" && s[0] == ' ')  s = s.substr(1);
+    if(s != "" && s[0] != '#') filenames.push_back(s);
+    }
+  
+  map<string, string> cas;
+  if(std::ifstream is = std::ifstream("devmods/rulegen-tests/kbmerge.txt")) {;
+    while(getline(is, s)) {
+      int i = 0, j = 0;
+      for(char c: s) { i++; if(c == ';') j = i; }
+      string fname = s.substr(j);
+      if(cas.count(fname) && cas[fname].substr(0,5) != s.substr(0,5)) {
+//        println(hlog, "repetition:\n", cas[fname], "\n", s);
+        s = min(s, cas[fname]);
+        }
+      cas[fname] = s;
+//      println(hlog, "assigned to ", fname, ": ", s);
+      }
+    }
+  
+  println(hlog, "CSV;kbres;Tp;kbrules;tree;maxlen;file");
+  
+  for(auto ss: filenames)
+    if(!cas.count(ss))
+      println(hlog, "MISSING: ", ss);
+    else
+      println(hlog, cas[ss]);  
+  }
+
+map<cell*, seq> first_seq_last;
+map<cell*, seq> first_seq;
+map<cell*, int> qty;
+
+void view_kb_tree(const shiftmatrix& V, cellwalker cw, seq s) {
+  qty[cw.at]++;
+  if(cw.at == lmouseover) println(hlog, s, " ; ", cw.spin);
+  for(int i=0; i<cw.at->type; i++) {
+    seq s1 = s;
+    s1.emplace_back(gen_symbol(shvid(cw.at), i));
+    if(is_end_reducible(s1)) continue;
+    auto cw1 = cw;
+    cw1 += i;
+    int is = cw1.spin;
+    cw1 += wstep;
+    if(!gmatrix.count(cw1.at)) continue;
+    transmatrix A = currentmap->adj(cw.at, is);
+    int eid = shvid(cw1.at);
+    int clen = arb::current.shapes[eid].cycle_length;
+    cw1 -= cw1.spin % clen;
+    // queueline(V * get_corner_position(cw.at, cw.spin, 6), V * A * get_corner_position(cw1.at, cw1.spin, 6), 0xC00000FF);
+    
+    seq s2 = s1;
+    s2.emplace_back(gen_symbol(shvid(cw1.at), 120));
+    
+    if(!is_end_reducible(s2)) { // first_seq_last[cw1.at] == s1) {
+      if(cw1.at == lmouseover) println(hlog, "is not end_reducible: ", s2);
+      vid.linewidth *= 3;
+      queueline(V * C0, V * mid(tC0(A), mid(C0, tC0(A))), 0xFFC0C0FF, 3);
+      vid.linewidth /= 3;
+      }
+    
+    if(!first_seq.count(cw1.at))
+      first_seq[cw1.at] = s1;
+    else
+      first_seq[cw1.at] = min(s1, first_seq[cw1.at]);
+
+    view_kb_tree(V*A, cw1, s1);
+    }
+  }
+
+void kb_marker() {
+  qty.clear();
+  first_seq_last = std::move(first_seq);
+  first_seq.clear();
+  view_kb_tree(gmatrix[cwt.at], cellwalker(cwt.at, 0), {});
+  for(auto p: qty)
+    queuestr(gmatrix[p.first], .5, its(p.second), 0xFFFFFFFF, 1);    
+  }
+
+void add_kb_view() {
+  addHook(hooks_markers, 100, kb_marker);
+  }
+
+int u = arg::add3("-kb", [] { 
+  test_knuth_bendix(); 
+  println(hlog, "result: ", kb_result, " rules: ", isize(rules));
+  println(hlog, "final rules:");
+  for(auto s: rules) println(hlog, s.first, " => ", s.second);
+  if(kb_result == 0) println(hlog, "tree states: ", count_tree_states());
+  }) 
+  + arg::add3("-kb-test-all", [] { arg::shift(); test_all(arg::args()); }) 
+  + arg::add3("-kb-forked", [] { arg::shift(); max_children = arg::argi(); forked = max_children; }) 
+  + arg::add3("-kb-rev", [] { arg::shift(); reversed = arg::argi(); }) 
+  + arg::add3("-kb-view", add_kb_view) 
+  + arg::add3("-kb-merge", kb_merge);
+
+}

devmods/manual-animation.cpp

@@ -0,0 +1,633 @@
+#include "../hyper.h"
+
+// A tool to create smooth manually controlled movement animations in 3D geometries.
+
+// Press 'f' to start controlling
+
+// 'qweasdzxc' will move the camera and additionally rotate the view a bit (except 's')
+
+// 'b' goes back 1 frame, 'e' undoes 30 frames
+
+// 'r' starts recording
+
+// 1234 change movement speed (see console for details)
+// 67890 change rotation speed (see console for details)
+
+namespace hr {
+
+bool saving_positions;
+
+bool smooth_aim = true;
+
+int next_pos_tick;
+
+struct frame {
+  transmatrix V;
+  transmatrix lp;
+  transmatrix msm;
+  cell *co;
+  int steps_to_change;
+  int step_smoothing;
+  ld stepdist;
+  ld stepang;
+  };
+
+vector<frame> saved;
+
+int collection;
+
+bool recording;
+bool keys_on = false;
+ld stepdist = 0.02;
+ld stepang = 0.01;
+EX int step_smoothing = 1;
+EX int steps_to_change;
+
+void move_camera1(transmatrix T);
+
+void recall(frame& f = saved.back()) {
+  View = f.V;
+  current_display->local_perspective = f.lp;
+  stretch::mstretch_matrix = f.msm;
+  centerover = f.co;
+  steps_to_change = f.steps_to_change;
+  step_smoothing = f.step_smoothing;
+  stepdist = f.stepdist;
+  stepang = f.stepang;
+  playermoved = false;
+  }
+
+frame saveframe() {
+  frame f;
+  f.V = View;
+  f.lp = current_display->local_perspective;
+  f.msm = stretch::mstretch_matrix;
+  f.co = centerover;
+  f.steps_to_change = steps_to_change;
+  f.step_smoothing = step_smoothing;
+  f.stepdist = stepdist;
+  f.stepang = stepang;
+  playermoved = false;
+  return f;
+  }
+
+void trailer_frame() {
+  // if(saving_positions || !isize(saved)) 
+  if(!recording && keys_on) queuestr(current_display->xcenter, current_display->ycenter, 0, 16, "+", 0xFFFFFFFF);
+  if(!recording && keys_on) queuestr(current_display->xcenter/2, current_display->ycenter, 0, 16, "+", 0xFFFFFFFF);
+  if(!recording && keys_on) queuestr(current_display->xcenter*3/2, current_display->ycenter, 0, 16, "+", 0xFFFFFFFF);
+  if(!recording && keys_on) queuestr(mousex, mousey, 0, 16, "+", 0xFFFFFFFF);
+  }
+
+ld next_stepdist = stepdist;
+ld next_stepang = stepang;
+
+void apply_steps_to_change() {
+  if(steps_to_change) {
+    stepang = stepang + (next_stepang-stepang) / steps_to_change;
+    stepdist = stepdist + (next_stepdist-stepdist) / steps_to_change;
+    steps_to_change--;
+    }
+  }
+
+bool trailer_turn(int delta) {
+  if(saving_positions) {
+    collection += delta * 60;
+    while(collection > 1000) {
+      apply_steps_to_change();
+      collection -= 1000;
+      View = cpush(2, -stepdist) * View;
+            
+      if(smooth_aim) {
+        ld dx = (mousex - current_display->xcenter) * stepang / -50.;
+        ld dy = (mousey - current_display->ycenter) * stepang / -50.;
+        View = cspin(0, 2, dx) * cspin(1, 2, dy) * View;
+        }
+      optimizeview();
+      saved.emplace_back(saveframe());
+      if(isize(saved) % 100 == 0)
+        println(hlog, "frames = ", isize(saved));
+      }
+    }
+  return true;
+  }
+
+ld spin_distance = 0;
+
+bool spinning_around;
+
+bool fixed_orientation;
+
+transmatrix orientation_to_fix;
+
+string videofile;
+
+void move_camera1(transmatrix T) {
+  // println(hlog, "rayfix: saving frame ", isize(saved));
+  // optimizeview();
+  // ray::cast();
+  optimizeview();
+  saved.emplace_back(saveframe());
+  if(spinning_around) {
+    for(int s=0; s<100; s++) 
+      shift_view(ztangent(-spin_distance/100));
+    rotate_view(T);
+    for(int s=0; s<100; s++) 
+      shift_view(ztangent(spin_distance/100));
+    }
+  else {
+    shift_view(ztangent(-stepdist));
+    spin_distance += stepdist;
+    rotate_view(T);
+    }
+  if(fixed_orientation) {
+    println(hlog, "cat ", inverse(View) * C0);
+    transmatrix iView = inverse(View);
+    iView = nisot::translate(iView * C0) * orientation_to_fix;
+    View = inverse(iView);
+    println(hlog, "cat ", inverse(View) * C0);
+    }
+  }
+
+bool move_camera(transmatrix T) {
+  for(int it=0; it<5; it++) 
+    move_camera1(T);
+  println(hlog, "frames = ", isize(saved), " distance = ", spin_distance);
+  playermoved = false;
+  return true;
+  }
+
+template<class Type> bool move_camera_smoothchange(const Type& T) {
+  for(int it=0; it<5; it++) {
+    println(hlog, "steps_to_change = ", steps_to_change, " stepdist = ", stepdist);
+    apply_steps_to_change();
+    move_camera1(T());
+    }
+  println(hlog, "frames = ", isize(saved), " distance = ", spin_distance);
+  playermoved = false;
+  return true;
+  }
+
+bool spin_around(transmatrix T) {
+  for(int it=0; it<5; it++) {
+    }
+  println(hlog, "frames = ", isize(saved), " spinning");
+  playermoved = false;
+  return true;
+  }
+
+namespace sn {   pair<heptagon*,heptagon*> getcoord(heptagon *h); }
+
+bignum bdiff(heptagon *h1, heptagon *h2) {
+  if(h1 == h2) return 0;
+  auto p = bdiff(h1->move(3), h2->move(3));
+  int d = h1->c.spin(3) - h2->c.spin(3);
+  println(hlog, "d=", d, " p = ", p.get_str(10000));
+  return p + p + bignum(d);
+  }
+
+#define BASE 10
+
+/*
+void o_addmul(bignum& b0, const bignum& b, int factor) {
+  int K = isize(b.digits);
+  if(K > isize(b0.digits)) b0.digits.resize(K);
+  int carry = 0;
+  for(int i=0; ; i++) {
+    bool cnt = (i<K || (carry > 0 && carry < -1) || (carry == -1 && i < isize(b0.digits)));
+    println(hlog, "cnt = ", cnt, " carry = ", carry
+    if(!cnt) break;
+    println(hlog, "i=", i, " carry start=", carry);
+    if(i >= isize(b0.digits)) b0.digits.push_back(0);
+    long long l = b0.digits[i];
+    l += carry;
+    if(i < K) l += b.digits[i] * factor;
+    carry = 0;
+    if(l >= BASE) carry = l / BASE;
+    if(l < 0) carry = -(BASE-1-l) / BASE;
+    l -= carry * BASE;
+    b0.digits[i] = l;
+    println(hlog, "carry=", carry);
+    }
+  println(hlog, "carry end=", carry);
+  if(carry < 0) b0.digits.back() -= BASE;
+  while(isize(b0.digits) && b0.digits.back() == 0) b0.digits.pop_back();
+  } */
+
+void get_b4_distance() {
+  heptagon *h1 = currentmap->gamestart()->master;
+  heptagon *h2 = centerover->master;
+  if(h1->distance != h2->distance)
+    println(hlog, "Z difference: ", h2->distance - h1->distance);
+  else if(sn::in()) {
+    auto c1 = sn::getcoord(h1);
+    auto c2 = sn::getcoord(h2);
+    println(hlog, "X difference: ", bdiff(c1.first, c2.first).get_str(10000));
+    println(hlog, "Y difference: ", bdiff(c1.second, c2.second).get_str(10000));
+    println(hlog, "X difference> ", bdiff(c2.first, c1.first).get_str(10000));
+    println(hlog, "Y difference> ", bdiff(c2.second, c1.second).get_str(10000));
+    }
+  }
+
+void load_animation(string fname) {
+  fhstream f(fname, "r");
+  int siz;
+  f.read<int>(siz);
+  saved.resize(siz);
+  for(int i=0; i<isize(saved); i++) {
+    auto& s = saved[i];
+    hread_raw(f, s.V);
+    hread_raw(f, s.lp);
+    int tmp = 0; hread_raw(f, tmp);
+    if(cryst) {
+      crystal::coord co;
+      hread_raw(f, co);
+      s.co = crystal::get_heptagon_at(co)->c7;
+      }
+    else
+    if(nil) {
+      nilv::mvec co;
+      hread_raw(f, co);
+      s.co = nilv::get_heptagon_at(co)->c7;
+      }
+    else if(bounded) {    
+      auto ac = currentmap->allcells();
+      int i;
+      hread_raw(f, i);
+      s.co = ac[i];
+      }
+    else s.co = cwt.at;
+    }
+  println(hlog, "loaded animation of ", isize(saved), " frames");
+  recall();
+  }
+
+EX transmatrix spintox_good(const hyperpoint& H) {
+  if(GDIM == 2 || prod) return spintox(H); 
+  double v = -atan2(H[2], H[1]);
+  return cspin(2, 1, -v) * spintoc(cspin(2, 1, v) * H, 0, 1) *cspin(2, 1, v);
+  // cspin(2, 1, v) * spintoc(cspin(2, 1, -v) * H, 0, 1);
+  }
+
+void denan() {
+  for(int i=1; i<isize(saved)-1; i++) {
+    auto& s = saved[i];
+    if(isnan(s.V[0][0])) {
+      println(hlog, "nan at ", i, " @ ", s.co);
+      saved[i] = saved[i-1];
+      }
+    }
+  }
+
+transmatrix relm(cell *a, cell *b) {
+  forCellIdEx(c, id, b) if(c == a) return currentmap->adj(b, id);
+  forCellIdEx(c, id, b) 
+    forCellIdEx(d, id2, c) if(d == a) return currentmap->adj(b, id) * currentmap->adj(c, id2);
+  return currentmap->relative_matrix(a, b, C0);
+  }  
+
+void smoothen() {
+  ld total = 0;
+  
+  for(int a=1; a<3; a++)
+  for(int i=1; i<isize(saved)-1; i++) if((a^i)&1) {
+    auto& s = saved[i];
+    auto& sl = saved[i-1];
+    auto& sn = saved[i+1];
+    forCellCM(c, s.co);
+    hyperpoint hl = s.V * relm(sl.co, s.co) * inverse(sl.V) * C0;
+    hyperpoint hn = s.V * relm(sl.co, s.co) * inverse(sn.V) * C0;
+    hyperpoint hm = mid(hl, hn);
+    if(isnan(hm[0])) {
+      println(hlog, "Vl = ", sl.V);
+      println(hlog, "V  = ", s.V);
+      println(hlog, "Vn = ", sn.V);
+      println(hlog, "cells ", sl.co, s.co, sn.co);
+      println(hlog, "crl= ", relm(sl.co, s.co));
+      println(hlog, "crm= ", relm(sn.co, s.co));
+      continue;
+      }
+    total += hdist0(hm);
+    s.V = gpushxto0(hm) * s.V;
+    auto xhn = gpushxto0(hm) * hn;
+    transmatrix T = cspin(0, 2, -M_PI/2) * spintox_good(cspin(0, 2, M_PI/2) * xhn) * cspin(0, 2, M_PI/2);
+    s.V = T * s.V;
+    // println(hlog, hn, " -> ", T * xhn);
+    }
+  println(hlog, "total = ", total);
+  }
+
+string mrec_file = "devmods/manual/%05d.png";
+
+int mrec_fps = 60;
+
+int mrec_first = 0, mrec_last = 999999;
+
+int mrec_first_opt = 0, mrec_last_opt = 0;
+
+void set_stepdist(ld x) {
+  println(hlog, "stepdist = ", x);
+  next_stepdist = x;
+  steps_to_change = step_smoothing;
+  }
+
+void set_stepang(ld x) {
+  println(hlog, "stepang = ", x);
+  next_stepang = x;
+  steps_to_change = step_smoothing;
+  }
+
+void do_recording() {
+  recording = true;
+  if(mouseaim_sensitivity) {
+    mouseaim_sensitivity = 0;
+    println(hlog, "disabled mouseaim");
+    return;
+    }
+  if(musicvolume) {
+    println(hlog, "disabled music");
+    musicvolume = 0;
+    Mix_VolumeMusic(0);
+    return;
+    }
+  
+  dynamicval dp(arg::pos, arg::pos);
+  dynamicval vs(vid, vid);
+  for(arg::pos=mrec_first_opt; arg::pos < mrec_last_opt; arg::pos++) {
+    int r = callhandlers(1, hooks_args);
+    switch (r) {
+      case 0: arg::lshift(); break;
+      case 1: 
+        printf("Unknown option: %s\n", arg::argcs()); break;
+      case 2:
+        printf("Error\n"); break;
+      }
+    }
+
+  println(hlog, "starting recording");
+  shot::take("anim/start.png");
+  saving_positions = false;
+//      vid.cells_drawn_limit = 1000000;      
+  int i = 0;
+
+  system("mkdir -p devmods/manual/");
+  
+  auto f = [&] {
+    for(auto& p: saved) {
+      recall(p);
+      println(hlog, "rayfix: render ", i);
+      ticks = i * 1000 / mrec_fps;
+      
+      if(i >= mrec_first && i < mrec_last) {
+        string s = hr::format(mrec_file.c_str(), i);
+        println(hlog, "recording frame ", i, "/", isize(saved), " to ", s);
+        shot::take(s);
+        }
+      else 
+        println(hlog, "skipping frame ", i);
+      
+      i++;
+      }
+    return true;
+    };
+    
+  if(videofile != "") {
+    anims::record_video(videofile, f);
+    }
+  else 
+    f();
+
+  // lasti = i;
+  recording = false;
+  }
+  
+void show_man_options() {
+  gamescreen(2);
+  dialog::init("manual animation");
+  
+  dialog::addSelItem("stepdist", fts(next_stepdist), 'd');
+  dialog::add_action([] {
+    dialog::editNumber(next_stepdist, 0, 1, 0.001, 0.02, "stepdist", "stepdist");
+    dialog::reaction = [] { set_stepdist(next_stepdist); };
+    });
+
+  dialog::addSelItem("stepang", fts(next_stepang), 'a');
+  dialog::add_action([] {
+    dialog::editNumber(next_stepang, 0, 1, 0.001, 0.02, "stepang", "stepang");
+    dialog::reaction = [] { set_stepang(next_stepang); };
+    });
+
+  dialog::addItem("b4 distance", 'b');
+  dialog::add_action(get_b4_distance);
+
+  dialog::addSelItem("step smoothing", its(step_smoothing), 's');
+  dialog::add_action([] {
+    dialog::editNumber(step_smoothing, 1, 30, 1, 1, "step_smoothing", "step_smoothing");
+    dialog::reaction = [] { steps_to_change = step_smoothing; };
+    });
+
+  dialog::addItem("save path", '[');
+  dialog::add_action([] {
+    fhstream f("devmods/manan-record.mar", "w");
+    f.write<int>(isize(saved));
+    for(int i=0; i<isize(saved); i++) {
+      auto& s = saved[i];
+      hwrite_raw(f, s.V);
+      hwrite_raw(f, s.lp);
+      int tmp = 0; hwrite_raw(f, tmp);
+      if(cryst) {
+        auto at = crystal::get_coord(s.co->master);
+        hwrite_raw(f, at);
+        }
+      else if(nil) {
+        auto at = nilv::get_coord(s.co->master);
+        hwrite_raw(f, at);
+        }
+      else if(bounded) {
+        auto ac = currentmap->allcells();
+        for(int i=0; i<isize(ac); i++) if(ac[i] == s.co)
+          hwrite_raw(f, i);
+        }
+      }
+    println(hlog, "saved animation of ", isize(saved), " frames");
+    });
+
+  dialog::addItem("load path", ']');
+  dialog::add_action([] {
+    load_animation("devmods/manan-record.mar");
+    });
+  
+  dialog::addItem("do record", 'r');
+  dialog::add_action(do_recording);
+
+  dialog::addItem("clear", 'c');
+  dialog::add_action([] { saved.clear(); });
+
+  dialog::display();      
+  }
+  
+bool trailer_handleKey(int sym, int uni) {  
+
+  if(sym == 'f' && (cmode & sm::NORMAL)) {
+    keys_on = !keys_on;
+    println(hlog, "keys_on = ", keys_on);
+    return true;
+    }
+
+  if(keys_on && (cmode & sm::NORMAL)) {
+
+    if(sym == ',') { vid.fov *= 1.1; mouseaim_sensitivity *= 1.1; println(hlog, "fov = ", vid.fov, " sens = ", mouseaim_sensitivity); }
+    if(sym == '.') { vid.fov /= 1.1; mouseaim_sensitivity /= 1.1; println(hlog, "fov = ", vid.fov, " sens = ", mouseaim_sensitivity); }
+
+    if(sym == 't') {
+      if(!saved.empty()) {
+        println(hlog, "frames = ", isize(saved));
+        saved.pop_back();
+        }
+      if(!saved.empty()) {
+        recall();
+        }
+      return true;
+      }
+  
+    /* if(sym == 'e') {
+      dialog::editNumber(stepdist, 0, 1, 0.1, 0.1, "", "");
+      dialog::scaleLog();
+      } */
+                
+    if(sym == 's') return move_camera_smoothchange([&] { return Id; });
+      
+    if(sym == 'a') return move_camera_smoothchange([&] { return cspin(0, 2, stepang); });
+  
+    if(sym == 'd') return move_camera_smoothchange([&] { return cspin(0, 2, -stepang); });
+  
+    if(sym == 'q') return move_camera_smoothchange([&] { return cspin(0, 2, stepang) * cspin(1, 2, stepang); });
+    if(sym == 'w') return move_camera_smoothchange([&] { return cspin(1, 2, stepang); });
+    if(sym == 'e') return move_camera_smoothchange([&] { return cspin(0, 2, -stepang) * cspin(1, 2, stepang); });
+  
+    if(sym == 'z') return move_camera_smoothchange([&] { return cspin(0, 2, stepang) * cspin(1, 2, -stepang); });
+    if(sym == 'x') return move_camera_smoothchange([&] { return cspin(1, 2, -stepang); });
+    if(sym == 'c') return move_camera_smoothchange([&] { return cspin(0, 2, -stepang) * cspin(1, 2, -stepang); });
+
+    
+    if(sym == '1') { set_stepdist(0); return true; }
+    if(sym == '2') { set_stepdist(0.005); return true; }
+    if(sym == '3') { set_stepdist(0.02); return true; }
+    if(sym == '5') { set_stepang(0); return true; }
+
+    if(sym == '6') { set_stepang(0.001); return true; }
+    if(sym == '7') { set_stepang(0.003); return true; }
+    if(sym == '8') { set_stepang(0.01); return true; }
+    if(sym == '9') { set_stepang(0.03); return true; }
+    if(sym == '0') { set_stepang(0.1); return true; }
+    
+    if(sym == 'o') { 
+      println(hlog, "spin_distance = ", spin_distance, " reset to 0, i to spin");
+      spin_distance = 0;
+      return true;
+      }
+    
+    if(sym == 'j') {      
+      fixed_orientation = !fixed_orientation;
+      orientation_to_fix = inverse(inverse(nisot::translate(inverse(View) * C0)) * inverse(View));
+
+
+      transmatrix iView = inverse(View);
+      orientation_to_fix = inverse(nisot::translate(iView * C0)) * iView;
+
+      println(hlog, "fixed_orientation = ", orientation_to_fix);
+      return true;
+      }
+  
+    if(sym == 'i') { 
+      spinning_around = !spinning_around;
+      if(spinning_around) println(hlog, "spinning mode");
+      else println(hlog, "tank mode");
+      }
+  
+    if(sym == SDLK_F4) {
+      saving_positions = !saving_positions;
+      next_pos_tick = ticks;
+      println(hlog, "saving_positions = ", saving_positions);
+      mouseaim_sensitivity = 0;
+      return true;
+      }
+  
+    if(sym == 'b' && isize(saved) > 1) {
+      saved.pop_back();
+      println(hlog, "back to ", isize(saved), " frames");
+      recall();
+      return true;
+      }
+  
+    if(sym == 'u') {
+      for(int i=0; i<30; i++) if(isize(saved)) saved.pop_back();
+      println(hlog, "back to ", isize(saved), " frames");
+      if(isize(saved)) recall();
+      return true;
+      }
+    
+    if(sym == 'r') pushScreen(show_man_options);
+    }
+    
+  return false;
+  }
+
+int ma_readArgs() {
+  using namespace arg;
+           
+  if(0) ;
+  else if(argis("-loada")) {
+    start_game();
+    shift(); load_animation(args());
+    }
+  else if(argis("-smoothen")) {
+    PHASEFROM(2); 
+    shift(); int nsm = argi();
+    denan();
+    for(int i=0; i<nsm; i++) smoothen();
+    }
+  else if(argis("-mrecf")) {
+    PHASEFROM(2);
+    shift(); mrec_first = argi();
+    }
+  else if(argis("-mrecl")) {
+    PHASEFROM(2);
+    shift(); mrec_last = argi();
+    }
+  else if(argis("-mrec-to")) {
+    PHASEFROM(2);
+    shift(); mrec_file = args();
+    }
+  else if(argis("-mrecv")) {
+    PHASEFROM(2);
+    shift(); videofile = args();
+    }
+  else if(argis("-mrec-fps")) {
+    PHASEFROM(2);
+    shift(); mrec_fps = argi();    
+    }
+  else if(argis("-shot-half")) {
+    shot::shotx /= 2;
+    shot::shoty /= 2;
+    }
+  else if(argis("-mrec-opt")) {
+    PHASEFROM(2);
+    shift(); string cap = args();
+    shift(); mrec_first_opt = pos;
+    while(args() != cap) shift();
+    mrec_last_opt = pos;
+    }
+  else return 1;
+  return 0;
+  }
+
+
+auto mahook = 
+  addHook(hooks_handleKey, 100, trailer_handleKey)
++ addHook(hooks_drawmap, 100, trailer_frame)
++ addHook(shmup::hooks_turn, 100, trailer_turn)
++ addHook(hooks_args, 100, ma_readArgs)
++ 0;
+
+}

devmods/musictable.cpp

@@ -0,0 +1,39 @@
+#include "../hyper.h"
+
+// a tool to generate the music tables for Android and iOS
+
+namespace hr {
+
+string crop(string s) {
+  string res;
+  for(char c: s) if(c == '-') res = ""; else res += c;
+  return res;
+  }
+
+string cropios(string s) {
+  string res;
+  for(char c: s) if(c == '.') return res; else res += c;
+  return res;
+  }
+
+auto aec = 
+  arg::add3("-music-ios", [] {
+    for(int i=0; i<landtypes; i++)
+      if(musfname[i] == "") printf("  NULL,\n");
+      else printf("  @\"%s\", // %2d : %s\n", cropios(musfname[i]).c_str(), i, dnameof(eLand(i)).c_str());
+    })
++ arg::add3("-music-android", [] {
+    for(int i=0; i<landtypes; i++)
+      if(musfname[i] != "") {
+        string s = musfname[i].substr(4, isize(musfname[i])-8);
+        printf("  if(curland == %2d) id = R.raw.%s; // %s\n", i, crop(s).c_str(), dnameof(eLand(i)).c_str());
+        }
+    })
++ arg::add3("-music-license", [] {
+    printf("musiclicense = \"");
+    for(int i=0; i<isize(musiclicense); i++)
+      if(musiclicense[i] == '\n') printf("\\n\"\n\"");  else printf("%c", musiclicense[i]);
+    printf("\";\n");
+    });
+
+}

devmods/reps/counter.cpp

@@ -0,0 +1,73 @@
+// a float-like type to count operations
+
+namespace reps {
+
+std::map<std::string, int> counts;
+
+#define C(x) {}
+
+std::array<int, 16> cbc;
+
+constexpr int cbcAdd = 1;
+constexpr int cbcMul = 2;
+constexpr int cbcDiv = 3;
+constexpr int cbcTrig = 4;
+
+struct countfloat {
+  ld x;
+
+  countfloat() {}
+  explicit countfloat(ld _x) : x(_x) {}
+  explicit operator ld() { return x; }
+  operator bool() { return x != 0; }
+  
+  countfloat operator +(countfloat a) const { C("plus"); cbc[1]++; return countfloat(x + a.x); }
+  countfloat operator -(countfloat a) const { C("plus"); cbc[1]++; return countfloat(x + a.x); }
+  countfloat operator -() const { return countfloat(-x); }
+  countfloat operator +() const { return countfloat(+x); }
+  countfloat operator *(countfloat a) const { C("mul"); cbc[2]++; return countfloat(x * a.x); }
+  countfloat operator /(countfloat a) const { C("div"); cbc[3]++; return countfloat(x / a.x); }
+
+  bool operator <(countfloat a) const { return x < a.x; }
+  bool operator >(countfloat a) const { return x > a.x; }
+  bool operator <=(countfloat a) const { return x <= a.x; }
+  bool operator >=(countfloat a) const { return x >= a.x; }
+
+  countfloat& operator +=(countfloat a) { C("plus"); cbc[1]++; x += a.x; return self; }
+  countfloat& operator -=(countfloat a) { C("plus"); cbc[1]++; x -= a.x; return self; }
+  countfloat& operator *=(countfloat a) { C("mul"); cbc[2]++; x *= a.x; return self; }
+  countfloat& operator /=(countfloat a) { C("mul"); cbc[2]++; x /= a.x; return self; }
+  countfloat& operator *=(int a) { if(a != 1 && a != -1) C("mul"+hr::its(a)); x *= a; return self; }
+  countfloat& operator /=(int a) { if(a != 1 && a != -1) C("div"+hr::its(a)); x /= a; return self; }
+
+  friend countfloat sin(countfloat a) { cbc[4]++; C("sin"); return countfloat(sin(a.x)); }
+  friend countfloat cos(countfloat a) { cbc[4]++; C("cos"); return countfloat(cos(a.x)); }
+  friend countfloat tan(countfloat a) { cbc[4]++; C("tan"); return countfloat(tan(a.x)); }
+  friend countfloat sinh(countfloat a) { cbc[4]++; C("sinh"); return countfloat(sinh(a.x)); }
+  friend countfloat cosh(countfloat a) { cbc[4]++; C("cosh"); return countfloat(cosh(a.x)); }
+  friend countfloat tanh(countfloat a) { cbc[4]++; C("cosh"); return countfloat(tanh(a.x)); }
+  friend countfloat asinh(countfloat a) { cbc[4]++; C("asinh"); return countfloat(asinh(a.x)); }
+  friend countfloat acosh(countfloat a) { cbc[4]++; C("acosh"); return countfloat(acosh(a.x)); }
+  friend countfloat acos(countfloat a) { cbc[4]++; C("acos"); return countfloat(acos(a.x)); }
+  friend countfloat exp(countfloat a) { cbc[4]++; C("exp"); return countfloat(exp(a.x)); }
+  friend countfloat log(countfloat a) { cbc[4]++; C("log"); return countfloat(log(a.x)); }
+  friend countfloat sqrt(countfloat a) { cbc[4]++; C("sqrt"); return countfloat(sqrt(a.x)); }
+  friend countfloat atan2(countfloat a, countfloat b) { cbc[4]++; C("atan"); return countfloat(atan2(a.x, b.x)); }
+  friend countfloat pow(countfloat a, ld b) { cbc[4]++; C("pow" + hr::fts(b)); return countfloat(pow(a.x, b)); }
+  friend countfloat abs(countfloat a) { return countfloat(abs(a.x)); }
+  countfloat operator *(int a) const { if(a != 1 && a != -1) C("mul" + hr::its(a)); return countfloat(x * a); }
+  countfloat operator /(int a) const { if(a != 1 && a != -1) C("div" + hr::its(a)); return countfloat(x / a); }
+
+  friend bool isinf(countfloat a) { return isinf(a.x); }
+  friend bool isnan(countfloat a) { return isnan(a.x); }
+  };
+
+template<> countfloat get_deg<countfloat> (int deg) { return countfloat( M_PI * deg / 180 ); }
+
+}
+
+namespace hr {
+  void print(hr::hstream& hs, ::reps::countfloat b) {
+    print(hs, b.x);
+    }
+}

devmods/reps/multivector.cpp

@@ -0,0 +1,330 @@
+namespace reps {
+
+TD struct mvector {
+  array<typename D::Number, D::Dim> values;
+  typename D::Number& operator [] (int i) { return values[i]; }
+  const typename D::Number& operator [] (int i) const { return values[i]; }
+  mvector operator + (const mvector& M) const {
+    mvector result;
+    for(int i=0; i<D::Dim; i++) result[i] = self[i] + M[i];
+    return result;
+    }
+  mvector operator - (const mvector& M) const {
+    mvector result;
+    for(int i=0; i<D::Dim; i++) result[i] = self[i] - M[i];
+    return result;
+    }
+  mvector operator * (const typename D::Number& x) const {
+    mvector result;
+    for(int i=0; i<D::Dim; i++) result[i] = self[i] * x;
+    return result;
+    }
+  mvector operator / (const typename D::Number& x) const {
+    mvector result;
+    for(int i=0; i<D::Dim; i++) result[i] = self[i] / x;
+    return result;
+    }
+  mvector operator * (int x) const {
+    mvector result;
+    for(int i=0; i<D::Dim; i++) result[i] = self[i] * x;
+    return result;
+    }
+  mvector operator / (int x) const {
+    mvector result;
+    for(int i=0; i<D::Dim; i++) result[i] = self[i] / x;
+    return result;
+    }
+  };
+
+TD struct matrix {
+  array<array<typename D::Number, D::Dim>, D::Dim> values;
+  array<typename D::Number, D::Dim>& operator [] (int i) { return values[i]; }
+  const array<typename D::Number, D::Dim>& operator [] (int i) const { return values[i]; }
+  matrix operator * (const matrix& M) const {
+    matrix result;
+    for(int i=0; i<D::Dim; i++)
+    for(int k=0; k<D::Dim; k++) {
+      result[i][k] = typename D::Number(0);
+      for(int j=0; j<D::Dim; j++) result[i][k] += self[i][j] * M[j][k];
+      }
+    return result;
+    }
+  mvector<D> operator * (const mvector<D>& V) const {
+    mvector<D> result;
+    for(int i=0; i<D::Dim; i++) {
+      result[i] = typename D::Number(0);
+      for(int j=0; j<D::Dim; j++) result[i] += self[i][j] * V[j];
+      }
+    return result;
+    }
+  matrix operator * (const typename D::Number& x) const {
+    matrix result;
+    for(int i=0; i<D::Dim; i++) for(int j=0; j<D::Dim; j++) result[i][j] = self[i][j] * x;
+    return result;
+    }
+  matrix operator / (const typename D::Number& x) const {
+    matrix result;
+    for(int i=0; i<D::Dim; i++) for(int j=0; j<D::Dim; j++) result[i][j] = self[i][j] / x;
+    return result;
+    }
+  matrix operator * (int x) const {
+    matrix result;
+    for(int i=0; i<D::Dim; i++) for(int j=0; j<D::Dim; j++) result[i][j] = self[i][j] * x;
+    return result;
+    }
+  matrix operator / (int x) const {
+    matrix result;
+    for(int i=0; i<D::Dim; i++) for(int j=0; j<D::Dim; j++) result[i][j] = self[i][j] / x;
+    return result;
+    }
+  };
+
+TD constexpr mvector<D> zero_vector() {
+  mvector<D> result;
+  for(int i=0; i<D::Dim; i++) result[i] = typename D::Number(0);
+  return result;
+  }
+
+TD constexpr mvector<D> unit_vector(int id) {
+  mvector<D> result;
+  for(int i=0; i<D::Dim; i++) result[i] = typename D::Number(0);
+  result[id] = typename D::Number(1);
+  return result;
+  }
+
+TD struct multivector_data {
+  using Number = typename D::Number;
+  static constexpr int Dim = 1<<D::Dim;
+  static constexpr int Flipped = -1;
+  };
+
+TD using multivector = mvector<multivector_data<D>>;
+
+TD std::string nz(const multivector<D>& a) {
+  constexpr int mdim = 1<<D::Dim;
+  using Number = typename D::Number;  
+  hr::shstream str;
+  for(int i=0; i<mdim; i++) if(abs(a[i]) > Number(1e-10)) {
+    if(str.s != "") print(str, " ");
+    if(a[i] > Number(0)) print(str, "+");
+    print(str, a[i]);
+    for(int u=0; u<D::Dim; u++) if(i & (1<<u)) print(str, hr::s0 + char('A'+u));
+    }
+  if(str.s == "") return "0";
+  return str.s;
+  }
+
+TD constexpr multivector<D> unit(const typename D::Number& a) {
+  auto res = zero_vector<multivector_data<D>>();
+  res[0] = a;
+  return res;
+  }
+
+TD constexpr multivector<D> embed(const mvector<D>& a) {
+  auto res = zero_vector<multivector_data<D>>();
+  for(int i=0; i<D::Dim; i++) res[1<<i] = a[i];
+  return res;
+  }
+
+TD constexpr mvector<D> unembed(const multivector<D>& a) {
+  mvector<D> res;
+  for(int i=0; i<D::Dim; i++) res[i] = a[1<<i];
+  return res;
+  }
+
+/* for clarity */
+using mvindex = int;
+using signtype = int;
+/* mvindex decimal 10 (binary 1010) corresponds to unit_vector(1) * unit_vector(3) */
+
+TD constexpr signtype conj_sign(mvindex mvid) {
+  int b = __builtin_popcount(mvid);
+  b = b * (b+1) / 2;
+  return (b&1) ? -1 : 1;
+  }
+
+TD constexpr signtype tra_sign(mvindex mvid) {
+  int b = __builtin_popcount(mvid);
+  b = b * (b-1) / 2;
+  return (b&1) ? -1 : 1;
+  }
+
+TD constexpr signtype mul_sign(mvindex a, mvindex b) {
+  int flips = 0;
+  for(int i=0; i<D::Dim; i++) if(b & (1<<i)) {
+    // we will need to swap it with that many 1-bits of a
+    flips += __builtin_popcount(a & ((1<<i)-1));
+    if((i == D::Flipped) && (a & (1<<i))) flips++;
+    }
+  return (flips&1) ? -1 : 1;
+  }
+
+TD struct all {
+  static constexpr bool check(mvindex a) { return true; }
+  static constexpr bool isflat(mvindex a) { return false; }
+  };
+
+TD struct even {
+  static constexpr bool check(mvindex a) { return __builtin_popcount(a) % 2 == 0; }
+  static constexpr bool isflat(mvindex a) { return false; }
+  };
+
+TD struct flat_even {
+  static constexpr bool check(mvindex a) { return __builtin_popcount(a) % 2 == 0; }
+  static constexpr bool isflat(mvindex a) { return nm == nmFlatten && a == 0; }
+  };
+
+TD struct odd {
+  static constexpr bool check(mvindex a) { return __builtin_popcount(a) % 2 == 1; }
+  static constexpr bool isflat(mvindex a) { return false; }
+  };
+
+TD struct units {
+  static constexpr bool check(mvindex a) { return a == 0; }
+  static constexpr bool isflat(mvindex a) { return false; }
+  };
+
+TD struct rotational {
+  static constexpr bool check(mvindex a) { return __builtin_popcount(a) % 2 == 0 && a < (1<<(D::Dim-1)); }
+  static constexpr bool isflat(mvindex a) { return false; }
+  };
+
+TD struct underling {
+  static constexpr bool check(mvindex a) { return __builtin_popcount(a) == 1; }
+  static constexpr bool isflat(mvindex a) { return false; }
+  };
+
+TD struct flat_underling {
+  static constexpr bool check(mvindex a) { return __builtin_popcount(a) == 1; }
+  static constexpr bool isflat(mvindex a) { return nm == nmFlatten && a == 1<<(D::Dim-1); }
+  };
+
+TD struct poincare {
+  static constexpr bool check(mvindex a) { return __builtin_popcount(a ^ (1<<(D::Dim-1))) == 1; }
+  static constexpr bool isflat(mvindex a) { return false; }
+  };
+
+TD multivector<D> multimul(const multivector<D>& a, const multivector<D>& b) {
+  constexpr int mdim = 1<<D::Dim;
+  auto res = zero_vector<multivector_data<D>>();
+  for(mvindex i=0; i<mdim; i++)
+  for(mvindex j=0; j<mdim; j++) {
+    res[i^j] += a[i] * b[j] * mul_sign<D>(i, j);
+    }
+  return res;
+  }
+
+template<class A, class B, class C, class D>
+multivector<D> chkmul(const multivector<D>& a, const multivector<D>& b) {
+  constexpr int mdim = 1<<D::Dim;
+  auto res = zero_vector<multivector_data<D>>();
+
+  /* we initialize with 0s and then add stuff, so one add per component is not necessary */
+  for(mvindex i=0; i<mdim; i++) if(C::check(i)) cbc[cbcAdd]--;
+
+  for(mvindex i=0; i<mdim; i++) if(A::check(i))
+  for(mvindex j=0; j<mdim; j++) if(B::check(j) && C::check(i^j)) {
+    if(A::isflat(i))
+      res[i^j] += b[j] * mul_sign<D>(i, j);
+    else if(B::isflat(j))
+      res[i^j] += a[i] * mul_sign<D>(i, j);
+    else
+      res[i^j] += a[i] * b[j] * mul_sign<D>(i, j);
+    }
+  return res;
+  }
+
+TD multivector<D> conjugate(const multivector<D>& a) {
+  constexpr int mdim = 1<<D::Dim;
+  auto res = a;
+  for(int i=0; i<mdim; i++) res[i] *= conj_sign<D>(i);
+  return res;
+  }
+
+TD multivector<D> transpose(const multivector<D>& a) {
+  constexpr int mdim = 1<<D::Dim;
+  auto res = a;
+  for(int i=0; i<mdim; i++) res[i] *= tra_sign<D>(i);
+  return res;
+  }
+
+template<class C, class D> multivector<D> apply_nm(multivector<D> a);
+
+TD using poincare_rotation = std::pair<multivector<D>, multivector<D>>;
+
+/** decompose o into the poincare part and the rotational component */
+TD poincare_rotation<D> despin2(const multivector<D>& a) {
+  auto p = a;
+  for(int i=(1<<(D::Dim-1)); i<(1<<(D::Dim)); i++) p[i] = typename D::Number(0);
+  p = p * pow(chkmul<rotational<D>,rotational<D>,units<D>>(p, conjugate(p))[0], -0.5);
+  auto p1 = chkmul<even<D>,rotational<D>,poincare<D>>(a, conjugate(p));
+  return {apply_nm<poincare<D>, D>(p1), p};
+  }
+
+/** remove the rotational component of a, leaving only the poincare part */
+TD multivector<D> despin(const multivector<D>& a) {
+  auto p = a;
+  for(int i=(1<<(D::Dim-1)); i<(1<<(D::Dim)); i++) p[i] = typename D::Number(0);
+  auto p1 = chkmul<even<D>,rotational<D>,poincare<D>>(a, conjugate(p));
+  if(nm == nmInvariant) return p1 * pow(chkmul<rotational<D>,rotational<D>,units<D>>(p, conjugate(p))[0], -0.5);
+  return apply_nm<poincare<D>, D>(p1);
+  }
+
+TD std::string nzv(const mvector<D>& a) { return "vector(" + nz(embed(a)) + ")"; }
+TD std::string nzv(const matrix<D>& a) { return "<matrix>"; }
+
+template<class C, class D>
+typename D::Number sqnorm(multivector<D> a) {
+  using N = typename D::Number;
+  auto res = chkmul<C, C, units<D>>(a, conjugate(a))[0];
+  if(res <= N(0) || isinf(res) || isnan(res)) res = N(1);
+  return res;
+  }
+
+TD typename D::Number sqnorm(mvector<D> a) { 
+  using N = typename D::Number;
+  N res(0);
+  for(int i=0; i<D::Dim; i++) res += a[i] * a[i] * (i == D::Flipped ? -1:1);
+  if(D::Flipped != -1) res = -res;
+  if(nm ==nmWeak && (res <= N(0) || isinf(res) || isnan(res))) res = N(1);
+  return res; 
+  }
+
+/** if nm is set to nmFlatten or nmForced or nmBinary, apply the requested operation */
+
+template<class C, class D> multivector<D> flatten(multivector<D> a) {
+  using N = typename D::Number;
+  auto divby = a[0]; a[0] = N(1);
+  for(int i=1; i<(1<<D::Dim); i++) if(C::check(i)) a[i] /= divby;
+  return a;
+  }
+
+template<class C, class D>
+multivector<D> apply_nm(multivector<D> a) {
+  if(nm == nmFlatten) return flatten<C>(a);
+  if(nm == nmForced || nm == nmWeak) return a * pow(sqnorm<C,D>(a), -0.5);
+  if(nm == nmBinary) { while(a[0] >= 2) { a = a / 2; } while(a[0] > 0 && a[0] < 0.5) { a = a * 2; } }
+  return a;
+  }
+
+TD mvector<D> apply_nm(mvector<D> a) {
+  if(nm == nmFlatten) { cbc[cbcDiv]--; return a / a[D::Dim-1]; }
+  if(nm == nmForced || nm == nmWeak) return a * pow(sqnorm<D>(a), -0.5);
+  if(nm == nmBinary) { while(a[D::Dim-1] >= 2) { a = a / 2; } while(a[D::Dim-1] > 0 && a[D::Dim-1] < 0.5) { a = a * 2; } }
+  return a;
+  }
+
+/** get b which is a coordinate of a, but in normalized form. That is, if a is normalized simply return b, otherwise, multiply b appropriately */
+
+template<class C, class D, class E> E get_normalized(multivector<D> a, E b) {
+  if(nm != nmInvariant && nm != nmForced) return b * pow(sqnorm<C,D>(a), -0.5);
+  return b;
+  }
+
+template<class D, class E> E get_normalized(mvector<D> a, E b) {
+  if(nm != nmInvariant && nm != nmForced) return b * pow(sqnorm<D>(a), -0.5);
+  return b;
+  }
+
+}
+

devmods/reps/rep-halfplane.cpp

@@ -0,0 +1,182 @@
+/** representation based on the halfplane model; assumes Dim=3 */
+
+namespace reps {
+
+template<class F> struct sl2 : public array<F, 4> {
+
+  sl2(F a, F b, F c, F d) { self[0] = a; self[1] = b; self[2] = c; self[3] = d; }
+  
+  sl2 operator * (const sl2& sec) const {
+    return sl2(
+      self[0] * sec[0] + self[1] * sec[2], 
+      self[0] * sec[1] + self[1] * sec[3], 
+      self[2] * sec[0] + self[3] * sec[2], 
+      self[2] * sec[1] + self[3] * sec[3]
+      );
+    }
+
+  std::string print() {
+    return hr::lalign(0, "[", self[0], ",", self[1], ";", self[2], ",", self[3], "]");
+    }
+
+  };
+
+TD sl2<typename D::Number> split_quaternion_to_sl2(const multivector<D>& h) {
+  auto h3 = h[0], h2 = h[1 | 2], h1 = h[1 | 4], h0 = h[2 | 4];
+  return sl2(h3 - h1, h2 + h0, -h2 + h0, h3 + h1);
+  }
+
+TD multivector<D> sl2_to_split_quaternion(const sl2<typename D::Number>& e) {
+  auto h0 = (e[1] + e[2]) / 2;
+  auto h3 = (e[0] + e[3]) / 2;
+  auto h1 = (e[3] - e[0]) / 2;
+  auto h2 = (e[1] - e[2]) / 2;
+  auto res = zero_vector<multivector_data<D>>();
+  res[0] = h3; res[1 | 2] = h2; res[1 | 4] = h1; res[2 | 4] = h0;
+  return res;
+  }
+
+template<class N> using sl2c = sl2<std::complex<N>>;
+
+TD sl2c<typename D::Number> split_biquaternion_to_sl2c(const multivector<D>& h) {
+  using cn = std::complex<typename D::Number>;
+  return sl2(cn(h[0]-h[9], h[15]-h[6]), cn(h[3]+h[10], -h[5]-h[12]), cn(h[10]-h[3], h[12]-h[5]), cn(h[0]+h[9], h[6]+h[15]));
+  }
+
+TD multivector<D> sl2c_to_split_biquaternion(const sl2c<typename D::Number>& e) {
+  auto res = zero_vector<multivector_data<D>>();
+  res[0]  = +(real(e[0]) + real(e[3])) / 2;
+  res[3]  = +(real(e[1]) - real(e[2])) / 2;
+  res[5]  = -(imag(e[1]) + imag(e[2])) / 2;
+  res[6]  = +(imag(e[3]) - imag(e[0])) / 2;
+  res[9]  = +(real(e[3]) - real(e[0])) / 2;
+  res[10] = +(real(e[1]) + real(e[2])) / 2;
+  res[12] = +(imag(e[2]) - imag(e[1])) / 2;
+  res[15] = +(imag(e[0]) + imag(e[3])) / 2;
+  return res;
+  }
+
+TD struct rep_halfplane {
+
+  using data = D;
+  using N = typename D::Number;
+  using point = std::complex<N>;
+  using isometry = sl2<N>;
+
+  static isometry cspin(int i, int j, N alpha) {
+    // return split_quaternion_to_sl2( rep_clifford<D>::cspin(i, j, alpha) );
+    if(i>j) std::swap(i, j), alpha = -alpha; alpha /= 2;
+    auto ca = cos(alpha), sa = sin(alpha);
+    return isometry(ca, -sa, sa, ca);
+    }
+  static isometry cspin90(int i, int j, N alpha) {
+    // return split_quaternion_to_sl2( rep_clifford<D>::cspin(i, j, alpha) );
+    auto ca = sqrt(N(2)), sa = sqrt(N(2));
+    if(i>j) std::swap(i, j), sa = -sa;
+    return isometry(ca, -sa, sa, ca);
+    }
+  static isometry lorentz(int i, int j, N alpha) {
+    // return split_quaternion_to_sl2( rep_clifford<D>::lorentz(i, j, alpha) );
+    if(i>j) std::swap(i, j); alpha /= 2;
+    if(i == 0) return isometry(exp(-alpha), N(0), N(0), exp(alpha));
+    if(i == 1) {
+      auto ca = cosh(alpha), sa = sinh(alpha);
+      return isometry(ca, sa, sa, ca);
+      }
+    throw hr::hr_exception("bad lorentz");
+    }
+  static isometry id() { return isometry(N(1),N(0),N(0),N(1)); };
+  static point center() { return point(N(0), N(1)); };
+  static point apply(const isometry& T, const point& x) { 
+    return (T[0] * x + T[1] * 1) / (T[2] * x + T[3] * 1);
+    };
+  static isometry apply(const isometry& T, const isometry& U) { return T * U; };
+
+  static typename rep_clifford<D>::point to_poincare(const point& x) {
+    auto a = real(x), b = imag(x);
+
+    auto tmp = isometry(sqrt(b), a/sqrt(b), N(0), N(1)/sqrt(b));
+    auto sq = sl2_to_split_quaternion<D>(tmp);
+
+    // sq[0] = (sqrt(b) + 1/sqrt(b)) / 2;; sq[1 | 2] = a/sqrt(b)/2; sq[1 | 4] = (1/sqrt(b) - sqrt(b)) / 2; sq[2 | 4] = a/sqrt(b)/2;
+   
+    sq = despin(sq);
+    return typename rep_clifford<D>::point({{sq}});
+    }
+
+  static isometry inverse(isometry T) { return isometry(T[3], -T[1], -T[2], T[0]); }
+  static isometry push(const point& p) { return split_quaternion_to_sl2<D>(to_poincare(p)[0]); }
+
+  static N dist0(const point& x) { return rep_clifford<D>::dist0(to_poincare(x)); } 
+  static N angle(const point& x) { return rep_clifford<D>::angle(to_poincare(x)); }
+  static N get_coord(const point& x, int i) { return rep_clifford<D>::get_coord(to_poincare(x), i); }
+
+  // imag may be very small and still important, so do not use the default complex print
+  static std::string print(const point& x) { return hr::lalign(0, "{real:", real(x), " imag:", imag(x), "}"); }
+  static std::string print(const isometry& x) { return x.print(); }
+  };
+
+TD struct rep_halfspace {
+
+  using data = D;
+  using N = typename D::Number;
+  struct point { std::complex<N> xy; N z; };
+  using isometry = sl2c<N>;
+
+  static isometry cspin(int i, int j, N alpha) {
+    return split_biquaternion_to_sl2c( rep_clifford<D>::cspin(i, j, alpha) );
+    }
+  static isometry cspin90(int i, int j) {
+    return split_biquaternion_to_sl2c( rep_clifford<D>::cspin90(i, j) );
+    }
+  static isometry lorentz(int i, int j, N alpha) {
+    return split_biquaternion_to_sl2c( rep_clifford<D>::lorentz(i, j, alpha) );
+    }
+  static isometry id() { return isometry(N(1),N(0),N(0),N(1)); }
+  static point center() { return point{ .xy = N(0), .z = N(1) }; }
+  static point apply(const isometry& T, const point& x) { 
+    auto nom = T[0] * x.xy + T[1] * N(1);
+    auto nomz= T[0] * x.z;
+    auto den = T[2] * x.xy + T[3] * N(1);
+    auto denz= T[2] * x.z;
+    // D = den + denz * j
+    auto dnorm = std::norm(den) + std::norm(denz);
+    using std::conj;
+    // conj(D) = conj(den) - denz * j
+    // N / D = (nom + nomz * j) / (den + denz * j) = 
+    // = (nom + nomz * j) * (conj(den) - denz * j) / dnorm
+    
+    // auto rxy  = (nom * conj(den) - nomz * j * denz * j);
+    // auto rz*j = (-nom * denz * j + nomz * j * conj(den))
+
+    // apply the formula: j * a = conj(a) * j
+
+    auto rxy = (nom * conj(den) + nomz * conj(denz));
+    auto rz  = (nomz * den - nom * denz); // todo only real part
+    // println(hlog, "imag of rz = ", imag(rz));
+    return point { .xy = rxy / dnorm, .z = real(rz) / dnorm };
+    };
+  static isometry apply(const isometry& T, const isometry& U) { return T * U; };
+
+  static typename rep_clifford<D>::point to_poincare(const point& x) {
+    auto tmp = isometry(sqrt(x.z), x.xy/sqrt(x.z), N(0), N(1)/sqrt(x.z));
+    auto sq = sl2c_to_split_biquaternion<D>(tmp);
+    sq = despin(sq);
+    return typename rep_clifford<D>::point({{sq}});
+    }
+
+  static isometry inverse(isometry T) { return isometry(T[3], -T[1], -T[2], T[0]); }
+  static isometry push(const point& p) { return split_biquaternion_to_sl2c<D>(to_poincare(p)[0]); }
+
+  static N dist0(const point& x) { return rep_clifford<D>::dist0(to_poincare(x)); } 
+  static N angle(const point& x) { return rep_clifford<D>::angle(to_poincare(x)); }
+  static N get_coord(const point& x, int i) { return rep_clifford<D>::get_coord(to_poincare(x), i); }
+
+  // imag may be very small and still important, so do not use the default complex print
+  static std::string print(const point& x) { return hr::lalign(0, "{x:", real(x.xy), " y:", imag(x.xy), " z:", x.z, "}"); }
+  static std::string print(const isometry& x) { return x.print(); }
+  };
+
+template<class D> using rep_half = typename std::conditional<D::Dim==3, rep_halfplane<D>, rep_halfspace<D>>::type;
+
+}

devmods/reps/rep-hr.cpp

@@ -0,0 +1,27 @@
+namespace reps {
+
+/* pull the HyperRogue representation; assumes HyperRogue geometry is set correctly, Number = ld, and Dim=3 or 4 */
+TD struct rep_hr {
+
+  using data = D;
+  using N = typename D::Number;
+  using point = hr::hyperpoint;
+  using isometry = hr::transmatrix;
+
+  static constexpr isometry cspin(int i, int j, N alpha) { return hr::cspin(i, j, ld(alpha)); }
+  static constexpr isometry cspin90(int i, int j) { return hr::cspin90(i, j); }
+  static constexpr isometry lorentz(int i, int j, N alpha) { return hr::lorentz(i, j, ld(alpha)); }
+  static isometry id() { return hr::Id; };
+  static point center() { return D::Dim == 4 ? hr::C03 : hr::C02; };
+  static point apply(const isometry& T, const point& x) { return T * x; };
+  static isometry apply(const isometry& T, const isometry& U) { return T * U; };
+  static ld dist0(const point& x) { return hdist0(x); } 
+  static ld angle(const point& x) { return atan2(x[1], x[0]); } 
+  static ld get_coord(const point& x, int i) { return x[i]; }
+  static isometry inverse(const isometry& T) { return iso_inverse(T); }
+  static isometry push(const point& p) { return rgpushxto0(p); }
+
+  static std::string print(point p) { return hr::lalign(0, p); }
+  static std::string print(isometry p) { return hr::lalign(0, p); }
+  };
+}

devmods/reps/rep-multi.cpp

@@ -0,0 +1,355 @@
+namespace reps {
+
+TD typename D::Number acos_auto(typename D::Number x) {
+  using N = typename D::Number;
+  if(hyperbolic) {
+    if(x < N(1)) return N(0);
+    return acosh(x);
+    }
+  if(sphere) {
+    if(x > N(1)) return N(0);
+    return acos(x);
+    }
+  throw hr::hr_exception("error");
+  }
+
+/* use the linear representation, as in HyperRogue, but DO NOT apply nm, for comparison */
+TD struct rep_linear_nn {
+
+  using data = D;
+  using point = mvector<data>;
+  using isometry = matrix<data>;
+  using N = typename D::Number;
+
+  static constexpr isometry id() { 
+    matrix<D> result;
+    for(int i=0; i<D::Dim; i++)
+    for(int j=0; j<D::Dim; j++)
+      result[i][j] = N(i == j);
+    return result;
+    };
+
+  static constexpr isometry cspin(int i, int j, typename D::Number angle) {
+    auto res = id();
+    auto ca = cos(angle), sa = sin(angle);
+    res[i][i] = ca;
+    res[j][j] = ca;
+    res[i][j] = sa;
+    res[j][i] = -sa;
+    return res;
+    };
+
+  static constexpr isometry cspin90(int i, int j) {
+    auto res = id();
+    res[i][i] = 0;
+    res[j][j] = 0;
+    res[i][j] = 1;
+    res[j][i] = -1;
+    return res;
+    };
+
+  static constexpr isometry lorentz(int i, int j, typename D::Number angle) {
+    auto res = id();
+    auto ca = cosh(angle), sa = sinh(angle);
+    res[i][i] = ca;
+    res[j][j] = ca;
+    res[i][j] = sa;
+    res[j][i] = sa;
+    return res;
+    }
+
+  static constexpr point center() { return unit_vector<data>(D::Dim-1); }
+  static point apply(const isometry& T, const point& x) { return T * x; };
+  static isometry apply(const isometry& T, const isometry& U) { return T * U; };
+  static typename D::Number dist0(point x) { 
+    return acos_auto<D> (x[D::Dim-1]);
+    } 
+  static typename D::Number angle(const point& x) { return atan2(x[1], x[0]); } 
+  static typename D::Number get_coord(point x, int i) { return x[i]; }
+
+  static isometry inverse(isometry T) { 
+    for(int i=0; i<D::Dim; i++)
+    for(int j=0; j<i; j++) std::swap(T[i][j], T[j][i]);
+    if constexpr(D::Flipped != -1) {
+      for(int i=0; i<D::Dim-1; i++) T[i][D::Dim-1] = -T[i][D::Dim-1];
+      for(int i=0; i<D::Dim-1; i++) T[D::Dim-1][i] = -T[D::Dim-1][i];
+      }
+    return T;
+    }
+  static isometry push(const point& p) {
+    auto res = id();
+    // to do: for spherical!
+    N fac = N(1)/(p[D::Dim-1]+N(1));
+    for(int i=0; i<D::Dim-1; i++)
+    for(int j=0; j<D::Dim-1; j++)
+      res[i][j] += p[i] * p[j] * fac;
+      
+    for(int d=0; d<D::Dim-1; d++)
+      res[d][D::Dim-1] = p[d],
+      res[D::Dim-1][d] = p[d];
+    res[D::Dim-1][D::Dim-1] = p[D::Dim-1];
+    
+    return res;
+    }
+
+  static std::string print(point p) { return nzv(p); }
+  static std::string print(isometry p) { return nzv(p); }
+  };
+
+TD mvector<D> get_column(matrix<D> a, int id) {
+  mvector<D> tmp;
+  for(int i=0; i<D::Dim; i++) tmp[i] = a[i][id];
+  return tmp;
+  }
+
+TD typename D::Number inner(mvector<D> a, mvector<D> b) {
+  using N = typename D::Number;
+  N res(0);
+  for(int i=0; i<D::Dim; i++) res += a[i] * b[i] * (i==D::Flipped?-1:1);
+  if(isnan(res) || isinf(res)) return N(0);
+  return res;
+  }
+
+TD void set_column(matrix<D>& a, int id, mvector<D> v) {
+  for(int i=0; i<D::Dim; i++) a[i][id] = v[i];
+  }
+
+TD typename D::Number sqnorm(matrix<D> a) { return sqnorm<D>(get_column<D>(a, D::Dim-1)); }
+
+bool fix_matrices;
+
+TD matrix<D> apply_nm(matrix<D> a) {
+  using N = typename D::Number;
+  // normalize first
+  auto& lead = a[D::Dim-1][D::Dim-1];
+  if(nm == nmFlatten) a = a / lead, cbc[cbcDiv]--;
+  if(nm == nmForced || nm == nmWeak) a = a * pow(sqnorm<D>(a), -0.5);
+  if(nm == nmBinary) { 
+    while(lead >= 2 && !isinf(lead)) { a = a / 2; } while(lead > 0 && lead < 0.5) { a = a * 2; } 
+    }
+  // fixmatrix later
+  if(!fix_matrices) return a;
+  auto divby = (nm == nmBinary || nm == nmWeak || nm == nmCareless || nm == nmFlatten) ? sqnorm<D>(a) : N(1);
+  for(int i=D::Dim-2; i>=0; i--) {
+    auto ro = get_column(a, i);
+    auto last = get_column(a, D::Dim-1);
+    ro = ro + last * inner(ro, last) / divby;
+    for(int j=i+1; j<D::Dim-1; j++) {
+      auto next = get_column(a, j);
+      ro = ro - next * inner(ro, next) / divby;
+      }
+    auto in = inner(ro, ro);
+    if(in > N(0)) ro = ro * (pow(in*in, -.5) * divby);
+    set_column(a, i, ro);
+    }
+  return a;
+  }
+
+/* use the linear representation, as in HyperRogue */
+TD struct rep_linear {
+
+  using data = D;
+  using point = mvector<data>;
+  using isometry = matrix<data>;
+  using N = typename D::Number;
+
+  static constexpr isometry cspin(int i, int j, typename D::Number angle) {
+    return apply_nm<D>( rep_linear_nn<D>::cspin(i, j, angle) );
+    }
+  static constexpr isometry cspin90(int i, int j) {
+    return rep_linear_nn<D>::cspin90(i, j);
+    }
+  static constexpr isometry lorentz(int i, int j, typename D::Number angle) {
+    return apply_nm<D>( rep_linear_nn<D>::lorentz(i, j, angle) );
+    }
+  static isometry id() { return rep_linear_nn<D>::id(); };
+  static constexpr point center() { return unit_vector<data>(D::Dim-1); }
+  static point apply(const isometry& T, const point& x) { return apply_nm(T * x); };
+  static isometry apply(const isometry& T, const isometry& U) { return apply_nm(T * U); };
+  static typename D::Number dist0(point x) { 
+    return acos_auto<D> (get_normalized(x, x[D::Dim-1]));
+    } 
+  static typename D::Number angle(const point& x) { return atan2(x[1], x[0]); } 
+  static typename D::Number get_coord(point x, int i) { 
+    return get_normalized(x, x[i]); }
+
+  static isometry inverse(isometry T) {
+    return rep_linear_nn<D>::inverse(T);
+    }
+  static isometry push(const point& p) {
+    return apply_nm( rep_linear_nn<D>::push(get_normalized(p, p)) );
+    }
+
+  static std::string print(point p) { return nzv(p); }
+  static std::string print(isometry p) { return nzv(p); }
+  };
+
+/* use the linear representation of points and the multivector representation of isometries */
+
+TD struct rep_mixed {
+
+  using data = D;
+  using N = typename D::Number;
+
+  using point = mvector<data>;
+  using isometry = multivector<data>;
+
+  static isometry cspin(int i, int j, typename data::Number alpha, bool noflat = false) {
+/*    auto u = unit_vector<multivector_data<data>> (0);
+    auto ui = unit_vector<data> (i);
+    auto uj = unit_vector<data> (j);
+    return u * cos(alpha/2) + multimul(embed(ui), embed(uj)) * sin(alpha/2); */
+    auto res = zero_vector<multivector_data<data>> ();
+    if(nm == nmFlatten && !noflat) {
+      res[0] = N(1);
+      res[(1<<i) | (1<<j)] = tan(alpha/2) * (i > j ? 1 : -1); 
+      return res;
+      }
+    res[0] = cos(alpha/2);
+    res[(1<<i) | (1<<j)] = sin(alpha/2) * (i > j ? 1 : -1); 
+    return res;
+    }
+
+  static isometry cspin90(int i, int j, bool noflat = false) {
+    auto res = zero_vector<multivector_data<data>> ();
+    if(nm == nmFlatten && !noflat) {
+      res[0] = N(1);
+      res[(1<<i) | (1<<j)] = N(i > j ? 1 : -1); 
+      return res;
+      }
+    res[0] = sqrt(N(.5));
+    res[(1<<i) | (1<<j)] = sqrt(N(.5)) * (i > j ? 1 : -1); 
+    return res;
+    }
+
+  static isometry lorentz(int i, int j, typename data::Number alpha) {
+/*  // j must be time coordinate
+    auto u = unit_vector<multivector_data<data>> (0);
+    auto ui = unit_vector<data> (i);
+    auto uj = unit_vector<data> (j);
+    return u * cosh(alpha/2) + multimul(embed(uj), embed(ui)) * sinh(alpha/2); */
+    auto res = zero_vector<multivector_data<data>> ();
+    if(nm == nmFlatten) {
+      res[0] = N(1);
+      res[(1<<i) | (1<<j)] = tanh(alpha/2);
+      return res; 
+      }
+    res[0] = cosh(alpha/2);
+    res[(1<<i) | (1<<j)] = sinh(alpha/2);
+    return res; 
+    }
+  static isometry id() { return unit_vector<multivector_data<data>> (0); };
+  static constexpr point center() { return unit_vector<data>(D::Dim-1); }
+  static point apply(const isometry& T, const point& x) {
+    // return unembed(multimul(multimul(T, embed(x)), conjugate(T)));
+    return apply_nm(unembed(chkmul<odd<D>,flat_even<D>,underling<D>>(chkmul<flat_even<D>,flat_underling<D>,odd<D>>(T, embed(x)), conjugate(T))));
+    };
+  static isometry apply(const isometry& T, const isometry& U) { 
+    auto res = apply_nm<even<D>, D>(chkmul<flat_even<D>,flat_even<D>,even<D>>(T, U));
+    return res;
+    }
+
+  static isometry inverse(isometry T) { return conjugate(T); }
+  static isometry push(const point& p) {
+    auto pm = get_normalized(p, p);
+    pm[D::Dim-1] = pm[D::Dim-1] + N(1);
+    // since p was normalized, sqnorm of pm is 2 * pm[D::Dim-1]
+    pm = pm * pow(2 * pm[D::Dim-1], -0.5);
+    multivector<data> v1 = embed(pm);
+    multivector<data> v2 = unit_vector<multivector_data<data>>(1<<(D::Dim-1));
+    multivector<data> v3 = chkmul<underling<D>,underling<D>,poincare<D>>(v1, v2);
+    v3 = apply_nm<poincare<D>, D>(v3);
+    return v3;
+    }
+
+  static typename D::Number dist0(point x) { return acos_auto<D> (get_normalized(x, x[D::Dim-1])); } 
+  static typename D::Number angle(const point& x) { return atan2(x[1], x[0]); } 
+  static typename D::Number get_coord(point x, int i) { return get_normalized(x, x[i]); }
+
+  static std::string print(point p) { return nzv(p); }
+  static std::string print(isometry p) { return nz(p); }
+  };
+
+/* use the hyperboloid-Poincare representation of points and the multivector representation of isometries */
+
+TD struct rep_clifford {
+
+  using data = D;
+  using N = typename D::Number;
+
+  using point = array< multivector<data>, 1>;
+  using isometry = multivector<data>;
+
+  static isometry cspin(int i, int j, typename data::Number alpha) { return rep_mixed<D>::cspin(i, j, alpha); }
+  static isometry cspin90(int i, int j) { return rep_mixed<D>::cspin90(i, j); }
+  // j must be the neg coordinate!
+  static isometry lorentz(int i, int j, N alpha) { return rep_mixed<D>::lorentz(i, j, alpha); }
+  static isometry id() { return rep_mixed<D>::id(); }
+  static constexpr point center() { return point{{ id() }}; }
+  static point apply(const isometry& T, const point& x) { return point{{ despin(chkmul<even<D>,poincare<D>,even<D>>(T, x[0])) }}; }
+  static isometry apply(const isometry& T, const isometry& U) { return apply_nm<even<D>,D>( chkmul<even<D>,even<D>,even<D>>(T, U) ); }
+
+  static isometry inverse(isometry T) { return conjugate(T); }
+  static isometry push(const point& p) { return p[0]; }
+
+  static typename D::Number dist0(const point& ax) { 
+    return acos_auto<D>(get_normalized<poincare<D>, D, N>(ax[0], ax[0][0]))*2;
+    } 
+  static constexpr int mvlast = 1<<(D::Dim-1);
+  static typename D::Number angle(const point& x) { 
+     return atan2(x[0][2 | mvlast], x[0][1 | mvlast]); 
+     } 
+  static typename D::Number get_coord(const point& x, int i) {
+    auto x1 = multimul(multimul(x[0], unit_vector<multivector_data<data>> (mvlast)), conjugate(x[0])); 
+    auto x2 = unembed(x1);
+    return get_normalized(x2, x2[i]);
+    }
+
+  static std::string print(point p) { return nz(p[0]); }
+  static std::string print(isometry p) { return nz(p); }
+  };
+
+/* split isometries into the poincare and rotational part */
+
+TD struct rep_gyro {
+
+  using data = D;
+  using N = typename D::Number;
+
+  using point = multivector<data>;
+  using isometry = poincare_rotation<data>;
+
+  static isometry cspin(int i, int j, typename data::Number alpha) { return { rep_mixed<D>::id(), rep_mixed<D>::cspin(i, j, alpha, true) }; }
+  static isometry cspin90(int i, int j, typename data::Number alpha) { return { rep_mixed<D>::id(), rep_mixed<D>::cspin90(i, j, alpha, true) }; }
+  static isometry lorentz(int i, int j, typename data::Number alpha) { return {rep_mixed<D>::lorentz(i, j, alpha), rep_mixed<D>::id() }; }
+  static isometry id() { return { rep_mixed<D>::id(), rep_mixed<D>::id() }; }
+  static constexpr point center() { return rep_mixed<D>::id(); }
+  static point apply(const isometry& T, const point& x) { return despin(chkmul<poincare<D>,poincare<D>,even<D>>(T.first, chkmul<rotational<D>,poincare<D>,poincare<D>>(T.second, x))); }
+  static isometry apply(const isometry& T, const isometry& U) {
+    auto R1 = apply_nm<rotational<D>, poincare<D>, poincare<D>> (T.second, U.first);
+    auto R2 = apply_nm<poincare<D>, poincare<D>, even<D>> (T.first, R1);
+    auto R3 = despin2(R2);
+    return { R3.first, apply_nm<rotational<D>, rotational<D>, rotational<D>> (R3.second, U.second) };
+    }
+
+  static isometry inverse(isometry T) { return { conjugate(T.first), conjugate(T.second) }; }
+  static isometry push(const point& p) { return { p, rep_mixed<D>::id() }; }
+
+  static typename D::Number dist0(const point& ax) { 
+    return acos_auto<D>(get_normalized<poincare<D>, D, N>(ax, ax[0]))*2;
+    } 
+  static constexpr int mvlast = 1<<(D::Dim-1);
+  static typename D::Number angle(const point& x) { 
+     return atan2(x[0][2 | mvlast], x[0][1 | mvlast]); 
+     } 
+  static typename D::Number get_coord(const point& x, int i) {
+    auto x1 = multimul(multimul(x[0], unit_vector<multivector_data<data>> (mvlast)), conjugate(x[0])); 
+    auto x2 = unembed(x1);
+    return get_normalized(x2, x2[i]);
+    }
+
+  static std::string print(point p) { return nz(p[0]); }
+  static std::string print(isometry p) { return "["+nz(p.first)+","+nz(p.second)+"]"; }
+  };
+
+}

devmods/reps/rep-polar.cpp

@@ -0,0 +1,261 @@
+bool polar_mod = true, polar_choose = true;
+
+namespace reps {
+
+template<class N> static void cyclefix(N& a) {
+  while(a > + get_deg<N>(180)) a -= get_deg<N>(360);
+  while(a < - get_deg<N>(180)) a += get_deg<N>(360);
+  }
+
+template<class N> static N cyclefix_on(N a) { cyclefix(a); return a; }
+
+/** the Taylor polynomial for 1-sqrt(1-y*y) */
+template<class N> N ssqrt(N y) {
+  return y*y/2 + y*y*y*y/8 + y*y*y*y*y*y*y/16 + y*y*y*y*y*y*y*y*y/128;
+  }
+
+TD struct rep_polar2 {
+
+  using data = D;
+  using N = typename D::Number;
+
+  struct point { N phi, r; };
+  struct isometry { N psi, phi, r; }; // spin by psi first
+
+  static isometry cspin(int i, int j, N alpha) {
+    if(i>j) std::swap(i, j), alpha = -alpha;
+    return isometry{.psi = -alpha, .phi = N(0), .r = N(0) };
+    }
+  static isometry cspin90(int i, int j) { return cspin(i, j, get_deg<N>(90)); }
+  static isometry lorentz(int i, int j, N alpha) {
+    if(i>j) std::swap(i, j);
+    if(i == 0) return isometry{.psi = N(0), .phi = N(0), .r = alpha};
+    if(i == 1) return isometry{.psi = N(0), .phi = get_deg<N>(90), .r = alpha};
+    throw hr::hr_exception("bad lorentz");
+    }
+  static isometry id() { return isometry{.psi = N(0), .phi = N(0), .r = N(0)}; };
+  static point center() { return point{.phi = N(0), .r = N(0)}; };
+
+  static std::string print(isometry T) {
+    return hr::lalign(0, "{phi=", T.phi, " r=", T.r, " psi=", T.psi, "}");
+    }
+
+  static std::string print(point T) {
+    return hr::lalign(0, "{phi=", T.phi, " r=", T.r, "}");
+    }
+
+  static isometry apply(isometry T, isometry U, bool need_psi = true) {
+    if(T.r == 0) return isometry {.psi = T.psi+U.psi, .phi = T.psi+U.phi, .r = U.r};
+    if(U.r == 0) return isometry {.psi = T.psi+U.psi, .phi = T.phi, .r = T.r};
+    N alpha = U.phi + T.psi - T.phi;
+    if(polar_mod) cyclefix(alpha);
+    isometry res;
+    N y1 = sinh(U.r) * sin(alpha);
+
+    auto ca = cos(alpha);
+    auto sa = sin(alpha);
+    N x1, x2;
+
+    // choose the appropriate method
+    if(polar_choose && ca >= N(0.5)) {
+      N u = ca >= N(.999999) ? ssqrt(sa) : N(1) - ca;
+      res.r = cosh(T.r + U.r) - u * sinh(T.r) * sinh(U.r);
+      x1 = sinh(T.r + U.r) - u * cosh(T.r) * sinh(U.r);
+      if(need_psi) x2 = sinh(T.r + U.r) - u * cosh(U.r) * sinh(T.r);
+      }
+    else if(polar_choose && ca <= N(-0.5)) {
+      N u = ca <= N(-.999999) ? ssqrt(-sa) : ca + N(1);
+      res.r = cosh(T.r - U.r) + u * sinh(T.r) * sinh(U.r);
+      x1 = sinh(T.r - U.r) + u * cosh(T.r) * sinh(U.r);
+      if(need_psi) x2 = sinh(U.r - T.r) + u * cosh(U.r) * sinh(T.r);
+      }
+    else {
+      res.r = sinh(T.r) * sinh(U.r) * ca + cosh(T.r) * cosh(U.r);
+      x1 = cosh(T.r) * sinh(U.r) * ca + cosh(U.r) * sinh(T.r);
+      if(need_psi) x2 = cosh(U.r) * sinh(T.r) * ca + cosh(T.r) * sinh(U.r);
+      }
+
+    if(res.r < N(1)) res.r = N(0); else res.r = acosh(res.r);
+
+    N beta  = (y1 || x1) ? atan2(y1, x1) : N(0);
+    res.phi = T.phi + beta;
+    if(polar_mod) cyclefix(res.phi);
+
+    if(need_psi) {
+      N y2 = sinh(T.r) * sin(alpha);
+      N gamma = (y2 || x2) ? atan2(y2, x2) : N(0);
+      res.psi = T.psi + U.psi + beta + gamma - alpha;
+      if(polar_mod) cyclefix(res.psi);
+      }
+
+    return res;
+    };
+
+  static point apply(const isometry& T, const point& x) { 
+    isometry x1 = apply(T, push(x), false);
+    return point { .phi = x1.phi, .r = x1.r};
+    };
+
+  static isometry inverse(isometry T) { return isometry{.psi = -T.psi, .phi = cyclefix_on<N>(get_deg<N>(180)+T.phi-T.psi), .r=T.r }; };
+  static isometry push(const point& p) { return isometry{.psi = N(0), .phi = p.phi, .r = p.r}; }
+
+  static N dist0(const point& x) { return x.r; } 
+  static N angle(const point& x) { return x.phi; }
+  static N get_coord(const point& x, int i) { 
+    if(i == 0) return cos(x.phi) * sinh(x.r);
+    if(i == 1) return sin(x.phi) * sinh(x.r);
+    if(i == 2) return cosh(x.r);
+    throw hr::hr_exception("bad get_coord");
+    }
+  };
+
+TD struct rep_high_polar {
+
+  using data = D;
+  using N = typename D::Number;
+
+  struct sphere_data {
+    using Number  = N;
+    static constexpr int Dim = D::Dim-1;
+    static constexpr int Flipped = -1;
+    };
+
+  using subsphere = rep_linear_nn<sphere_data>;
+
+  struct point { typename subsphere::point phi; N r; };
+  struct isometry { typename subsphere::isometry psi; typename subsphere::point phi; N r; };
+
+  static isometry cspin(int i, int j, N alpha) {
+    return isometry{.psi = subsphere::cspin(i, j, alpha), .phi = subsphere::center(), .r = N(0) };
+    }
+  static isometry cspin90(int i, int j) {
+    return isometry{.psi = subsphere::cspin90(i, j), .phi = subsphere::center(), .r = N(0) };
+    }
+  static isometry lorentz(int i, int j, N alpha) {
+    if(i>j) std::swap(i, j);
+    auto is = isometry{.psi = subsphere::id(), .phi = subsphere::center(), .r = alpha};
+    is.phi[D::Dim-2] = N(0);
+    is.phi[i] = N(1);
+    return is;
+    }
+  static isometry id() { return isometry{.psi = subsphere::id(), .phi = subsphere::center(), .r = N(0)}; }
+  static point center() { return point{.phi = subsphere::center(), .r = N(0)}; };
+
+  static std::string print(isometry T) {
+    return hr::lalign(0, "{phi=", subsphere::print(T.phi), " r=", T.r, " psi=", hr::kz(T.psi.values), "}");
+    }
+
+  static std::string print(point T) {
+    return hr::lalign(0, "{phi=", subsphere::print(T.phi), " r=", T.r, "}");
+    }
+
+  static isometry apply(isometry T, isometry U, bool need_psi = true) {
+    auto apsi = need_psi ? T.psi * U.psi : subsphere::id();
+    if(T.r == 0) return isometry {.psi = apsi, .phi = T.psi*U.phi, .r = U.r};
+    if(U.r == 0) return isometry {.psi = apsi, .phi = T.phi, .r = T.r};
+    auto aphi = T.psi * U.phi;
+    auto cos_alpha = inner<sphere_data>(aphi, T.phi);
+    auto& ca = cos_alpha;
+
+    isometry res;
+
+    N x1, x2;
+
+    auto orth = (aphi - T.phi * ca);
+    N sin_alpha;
+    if(ca > N(0.999999) || ca < N(0.999999))
+      sin_alpha = pow(sqnorm<sphere_data>(orth), .5);
+    else
+      sin_alpha = pow(N(1) - ca * ca, .5);
+
+    if(sin_alpha == N(0)) {
+      if(ca >= N(1)) {
+        return isometry{.psi = apsi, .phi = T.phi, .r = T.r + U.r };
+        }
+      if(ca <= N(-1)) {
+        if(T.r >= U.r) {
+          return isometry{.psi = apsi, .phi = T.phi, .r = T.r - U.r };
+          }
+        else {
+          return isometry{.psi = apsi, .phi = T.phi*-1, .r = U.r - T.r };
+          }
+        }
+      }
+
+    orth = orth / sin_alpha;
+    N y1 = sinh(U.r) * sin_alpha;
+
+    // choose the appropriate method
+    if(polar_choose && ca >= N(0.5)) {
+      N u = ca >= N(.999999) ? ssqrt(sin_alpha) : N(1) - ca;
+      res.r = cosh(T.r + U.r) - u * sinh(T.r) * sinh(U.r);
+      x1 = sinh(T.r + U.r) - u * cosh(T.r) * sinh(U.r);
+      if(need_psi) x2 = sinh(T.r + U.r) - u * cosh(U.r) * sinh(T.r);
+      }
+    else if(polar_choose && ca <= N(-0.5)) {
+      N u = ca <= N(-.999999) ? ssqrt(sin_alpha) : ca + N(1); // ca = u - 1
+      res.r = cosh(T.r - U.r) + u * sinh(T.r) * sinh(U.r);
+      x1 = sinh(T.r - U.r) + u * cosh(T.r) * sinh(U.r);
+      if(need_psi) x2 = sinh(U.r - T.r) + u * cosh(U.r) * sinh(T.r);
+      }
+    else {
+      res.r = sinh(T.r) * sinh(U.r) * ca + cosh(T.r) * cosh(U.r);
+      x1 = cosh(T.r) * sinh(U.r) * ca + cosh(U.r) * sinh(T.r);
+      if(need_psi) x2 = cosh(U.r) * sinh(T.r) * ca + cosh(T.r) * sinh(U.r);
+      }
+
+    if(res.r < N(1)) res.r = N(0); else res.r = acosh(res.r);
+
+    auto h1 = pow(x1*x1+y1*y1, -0.5);
+    N cos_beta = x1*h1, sin_beta = y1*h1;
+
+    res.phi = T.phi * cos_beta + orth * sin_beta;
+
+    if(need_psi) {
+      N y2 = sinh(T.r) * sin_alpha;
+      auto h2 = pow(x2*x2+y2*y2, -0.5);
+      N cos_gamma = x2*h2, sin_gamma = y2*h2;
+
+      // delta = beta + gamma - alpha
+
+      auto cos_beta_gamma = cos_beta * cos_gamma - sin_beta * sin_gamma;
+      auto sin_beta_gamma = cos_beta * sin_gamma + sin_beta * cos_gamma;
+
+      auto cos_delta = cos_beta_gamma * cos_alpha + sin_beta_gamma * sin_alpha;
+      auto sin_delta = sin_beta_gamma * cos_alpha - cos_beta_gamma * sin_alpha;
+
+      auto phi1  = T.phi  * cos_delta + orth  * sin_delta;
+      auto orth1 = orth   * cos_delta - T.phi * sin_delta;
+
+      auto phi2  = phi1  - T.phi;
+      auto orth2 = orth1 - orth;
+      typename subsphere::isometry spinner = subsphere::id();
+
+      // Tv = v + <v, phi> * (phi'-phi) + <v, orth> * (orth'-orth)
+
+      for(int i=0; i<D::Dim-1; i++)
+      for(int j=0; j<D::Dim-1; j++)
+        spinner[i][j] += phi2[i] * T.phi[j] + orth2[i] * orth[j];
+
+      res.psi = spinner * apsi;
+      }
+
+    return res;
+    };
+
+  static point apply(const isometry& T, const point& x) { 
+    isometry x1 = apply(T, push(x), false);
+    return point { .phi = x1.phi, .r = x1.r};
+    };
+
+  static isometry inverse(isometry T) { return isometry{.psi = subsphere::inverse(T.psi), .phi = subsphere::inverse(T.psi)*T.phi*-1, .r=T.r }; };
+  static isometry push(const point& p) { return isometry{.psi = subsphere::id(), .phi = p.phi, .r = p.r}; }
+
+  static N dist0(const point& x) { return x.r; } 
+  static N angle(const point& x) { return subsphere::angle(x.phi); }
+  static N get_coord(const point& x, int i) { if(i == D::Dim-1) return cosh(x.r); else return x.phi[i] * sinh(x.r); }
+  };
+
+template<class D> using rep_polar = typename std::conditional<D::Dim==3, rep_polar2<D>, rep_high_polar<D>>::type;
+
+}

devmods/reps/reps.cpp

@@ -0,0 +1,81 @@
+#include <boost/multiprecision/mpfr.hpp>
+
+#include "../../hyper.h"
+
+#define TD template<class D>
+#undef sl2
+
+namespace reps {
+
+using namespace boost::multiprecision;
+using big = mpfr_float_50;
+}
+
+namespace hr {
+  void print(hr::hstream& hs, ::reps::big b) {
+    std::stringstream ss; 
+    ss << std::setprecision(10);
+    ss << b; string u; ss >> u; print(hs, u);
+    }
+}
+
+namespace reps {
+using std::array;
+using std::vector;
+
+using hr::cell;
+using hr::print;
+using hr::hlog;
+using hr::celldistance;
+using hr::ld;
+using hr::ginf;
+using hr::geometry;
+using hr::gcHyperbolic;
+using hr::gcSphere;
+using hr::C02;
+using hr::C03;
+using hr::qANYQ;
+
+template <class N> N get_deg(int deg);
+template<> ld get_deg<ld> (int deg) { return M_PI*deg/180; }
+template<> big get_deg<big> (int deg) { return atan(big(1))*deg/45; }
+
+enum eNormalizeMode { 
+  nmInvariant,   // if the input was normalized, the output will be normalized too
+  nmForced,      // normalize the output
+  nmWeak,        // weakly normalize the output
+  nmCareless,    // do not try to keep the output normalized
+  nmFlatten,     // flatten the representation
+  nmBinary       // try to avoid overflow
+  };
+
+eNormalizeMode nm;
+
+}
+
+#include "counter.cpp"
+#include "multivector.cpp"
+#include "rep-hr.cpp"
+#include "rep-multi.cpp"
+#include "rep-halfplane.cpp"
+#include "rep-polar.cpp"
+#include "tests.cpp"
+
+namespace reps {
+
+// -- tests ---
+
+void test_systems() {
+  run_all_tests();
+  fflush(stdout);
+  exit(1);
+  }
+
+void set_repgeo() {
+  if(test_dim == 3) { hr::set_geometry(hr::gNormal); hr::set_variation(hr::eVariation::pure); }
+  if(test_dim == 4) { hr::set_geometry(hr::gSpace435); }
+  }
+
+int a = hr::arg::add1("-test-reps", test_systems) + hr::arg::add1("-repgeo", set_repgeo);
+
+}

devmods/reps/results.Md

@@ -0,0 +1,733 @@
+# What is it 
+
+This is a study of numerical precision errors in various representations of 2D hyperbolic geometry.
+It is generally the best to combine a representation with tiling; the tests take this into
+account.
+
+# Representations studied
+
+The following representations are studied:
+
+* **linear**: points in the hyperboloid model; isometries as linear transformation matrices.
+
+* **mixed**: points in the hyperboloid model; isometries using Clifford algebras. (Clifford algebras
+  are a generalization of 'quaternions' commonly used in 3D graphics.)
+
+* **clifford**: points are also represented using Clifford algebras, that is, p is represented as
+  the isometry u such as u(C0) = p and u does not introduce extra rotations.
+
+* **halfplane (2D)**: points are represented using the half-plane model; isometries are represented using
+  SL(2,R).
+
+* **halfspace (3D)**: points are represented using the half-space model; isometries are represented using
+  SL(2,C).
+
+* **polar 2D**: points are represented using polar coordinates; isometries need one extra angle.
+
+* **general polar**: like polar 2D, but instead of angles, we use rotated unit vectors and rotation
+  matrices; this also makes it work in higher dimension.
+
+## Variations
+
+Both in linear and Clifford representations, there is the correct "normalized" representation;
+if the normalized representation is multiplied by some factor x, most formulas still work, 
+and for those which do not, it is easy to compute x. This yields the following variations:
+
+* **invariant**: keep the invariant that the points and isometries are normalized
+  (that is: output is normalized under the assumption that the input is normalized)
+
+* **careless**: do not care about normalization
+  (advantages: some computations are avoided; possible to represent ultra-ideal points in
+  linear representations)
+
+* **forced**: normalize the output after every computation
+  (might be a good idea for points/isometries close to the center, but generally a bad 
+  idea if they are far away -- in that case, the norm generally cannot be computed, but 
+  distances and angles still tend to be correct in the invariant computations)
+
+* **weakly forced**: like forced, but do not normalize if the norm could not be computed
+  due to precision errors
+
+* **flatten**: instead of normal normalization, make the leading coordinate equal to 1.
+  The leading coordinate is the 'timelike' coordinate of linear representations
+  of points, and the 'unit' coordinate of Clifford representations.
+  (advantage: save memory: H2 represented only 2 coordinates instead of 3; 
+  disadvantage: might not represent ultra-ideal points if they would be infinite)
+
+* **binary**: in careless, values may easily explode and cause underflow/overflow; avoid this
+  by making the leading coordinate in \[0.5, 2) range (by multiplying by powers of 2, which is
+  presumably fast)
+
+Furthermore:
+* in linear, matrices can be **fixed** by replacing them by a correct orthogonal matrix close
+  to the current computation
+* in (non-general) polar, forcing angles into [-pi,pi] may be needed to prevent explosion
+* in **improved** polar, one of three variants of the cosine rule can be used, depending on the angle,
+  to improve the numerical precision; also even more precise computation to avoid numerical
+  precision errors for angles very close to 0 or pi
+* in the Clifford representation, the **gyro** variant splits the isometries into 
+  the translational part (which is flattened, making it equivalent to the Poincare disk model)
+  and the rotational part (for which 'invariant' is used). This fixes the problem 
+  with full flattening where rotations by 180° are flattened to infinity. (AFAIK
+  Hyperbolica uses roughly this)
+
+## Observations
+
+* except linear, all the methods of representing isometries can only represent
+  orientation-preserving ones
+
+* Clifford isometries of H2 is essentially the same as SL(2,R) of halfplane -- it is
+  just the change of the basis
+
+* linear/Clifford representations are not that good at representing points close to the
+  boundary of the disk (invariant can somewhat tell the distance but flattened cannot); 
+  halfplane is better here
+
+# Tests
+
+## test_loop_iso
+
+In this test, for each i, we construct a path in the tiling by always moving to a random
+adjacent tile, until we get to a tile i afar; then, we return to the start (also randomly,
+may stray further from the path). We compose all the relative tile isometries into T and see
+if T(C0) = C0. The score is the first i for which it fails.
+
+Discussion: This makes rep_mixed worse than rep_lorentz.
+
+## test_loop_point
+
+Same as test_loop_iso but we apply the consecutive isometries to point right away.
+
+Discussion: This makes rep_mixed worse than rep_lorentz.
+
+## test_angledist
+
+For each i (skipping some), construct a path outwards in the tiling, compose isometries,
+and see if the distance and angle to that tile have been computed correctly.
+
+Discussion: Invariant representations have no problem with this, even if the points obtained are beyond the precision otherwise.
+
+## test_similarity, test_dissimilarity, test_other
+
+For each i, compute the distance between two points in distance i from the starting point. 
+The angle between them is very small (test_similarity), close to 180° (test_dissimilarity),
+close to 1° (test_other). 
+
+Discussion: Similarity is obviously the most difficult. Halfplane is surprisingly powerful in all cases.
+
+## test_walk
+
+This is essentially walking in a straight line in HyperRogue. After some time, it can be often clearly observed that we
+have 'deviated' from the original straight line. This test checks how long we can walk.
+
+We construct an isometry T representing a random direction. In each step, we compose this isometry with a translation (T := T * translate(1/16)).
+Whenever the point T * C0 is closer to the center of another tile, we rebase to that new tile.
+
+For a test, we actually do this in parallel with two isometries T0 and T1, where T1 = T0 * translate(1/32). We count the number of steps
+until the paths diverge. Numbers over 1000 are not actually that good, 1000+n means that, after n steps, the implementation no longer detects tile
+changes. Numbers of 10000 signify that some even weirder problem happened.
+
+Discussion: Since the isometry matrices are always small (constrained to tiles), fixing definitely helps here. Without fixing, T stops
+being an isometry (an effect visible in HyperRogue when fixing is disabled).
+
+## test_close
+
+Here we see whether small errors accumulate when moving close to the center. In test i, we move randomly until we reach distance i+1,
+after which we return to the start (always reducing the distance). After each return to the start, we check if the representation is
+still fine (if not, we restart with the original representation). The number given is the number of errors in 10000 steps.
+
+Discussion: Errors do not appear to accumulate when we simply move close to the start (or rather, they accumulate very slowly).
+
+## test_count
+
+This simply computes the number of numerical operations performed for every geometric operation. Numerical operations are categorized as:
+* Addition/subtraction
+* Multiplication (multiplication by constant not counted)
+* Division (division by constant not counted)
+* Functions: exp, log, (a)sin/cos/tan(h), sqrt, inverse sqrt
+
+Geometric operations are:
+* spin: return rotation by given angle in given axes
+* L0: return translation by given value in axis 0
+* L1: return translation by given value in axis 1
+* ip: apply isometry to point
+* ii: compose isometries
+* d0: compute the distance of point from 0
+* angle: compute the (2D) angle of point
+* inverse: compute the inverse of an isometry
+* push: convert a point into a translation
+
+# Implementation notes
+
+Note: the program currently assumes hyperbolic geometry (it was intended to support spherical
+geometry but not everywhere the correct handling is implemented).
+
+# Results
+
+## Results on the {7,3} tiling
+
+```
+  test_loop_iso
+  linear+F  invariant: (17,16,17,16,17,17,17,17,16,17,17,17,17,16,16,17,17,16,17,17)
+  linear+F  forced   : (20,19,19,20,20,19,20,20,19,20,20,18,19,19,19,19,20,19,19,19)
+  linear+F  weak     : (21,19,20,20,20,19,24,20,19,25,24,18,19,19,19,19,20,19,19,19)
+  linear+F  flatten  : (19,19,21,20,20,20,20,20,19,19,19,21,19,20,19,19,19,19,19,20)
+  linear+F  careless : (19,19,19,19,20,19,20,20,19,20,18,18,19,18,19,19,19,19,19,19)
+  linear+F  binary   : (19,19,19,19,20,19,20,20,19,20,18,18,19,18,19,19,19,19,19,19)
+  linear-F  invariant: (17,17,17,18,18,18,21,17,16,17,19,18,17,18,23,17,18,17,19,17)
+  linear-F  forced   : (19,19,19,19,20,19,19,20,19,20,20,20,19,19,19,19,19,19,19,19)
+  linear-F  weak     : (19,19,20,19,20,19,19,20,19,21,20,20,21,19,19,19,20,19,19,19)
+  linear-F  flatten  : (20,19,20,20,21,19,20,18,19,19,20,21,19,21,20,19,19,19,19,20)
+  linear-F  careless : (20,19,19,21,19,19,20,17,19,20,19,20,19,19,19,19,19,19,19,20)
+  linear-F  binary   : (20,19,19,21,19,19,20,17,19,20,19,20,19,19,19,19,19,19,19,20)
+  mixed     invariant: (34,35,34,36,34,35,34,34,36,35,34,35,36,34,35,34,33,35,32,36)
+  mixed     forced   : (34,34,34,35,34,36,33,34,36,35,35,36,36,34,35,34,34,35,34,34)
+  mixed     weak     : (34,34,34,35,34,36,33,34,36,35,35,36,36,34,35,34,34,35,34,34)
+  mixed     flatten  : (20,5,18,13,13,13,4,13,9,29,25,9,36,22,19,30,5,35,14,2)
+  mixed     careless : (34,34,34,35,34,34,35,34,36,35,35,36,36,34,35,34,35,35,34,34)
+  mixed     binary   : (34,34,34,35,34,34,35,34,36,35,35,36,36,34,35,34,35,35,34,34)
+  Clifford  invariant: (32,35,34,36,34,35,34,34,36,33,34,35,36,34,35,34,33,34,32,36)
+  Clifford  forced   : (34,34,34,35,34,36,33,34,36,35,35,36,36,34,35,34,34,35,34,34)
+  Clifford  weak     : (34,34,34,35,34,36,33,34,36,35,35,36,36,34,35,34,34,35,34,34)
+  Clifford  flatten  : (34,34,34,35,34,36,35,34,36,35,35,36,37,34,35,34,36,35,34,34)
+  Clifford  careless : (34,34,34,35,34,34,35,34,36,35,35,36,36,34,35,34,35,35,34,34)
+  Clifford  binary   : (34,34,34,35,34,34,35,34,36,35,35,36,36,34,35,34,35,35,34,34)
+  Clifford  gyro     : (34,34,34,35,34,36,35,34,36,35,35,36,36,34,35,34,35,35,34,34)
+  halfplane invariant: (34,34,34,35,34,36,35,34,36,35,35,36,36,34,35,34,35,35,34,34)
+  polar     basic    : (34,34,34,35,34,34,33,34,36,35,35,24,36,34,35,34,35,35,34,34)
+  polar     improved : (34,34,34,34,33,36,35,33,36,35,35,36,35,34,35,34,34,35,34,35)
+  polar     F/F      : (34,36,35,35,33,34,33,33,36,35,35,36,36,34,35,34,35,35,34,34)
+  polar     F/T      : (34,34,34,34,33,36,35,33,36,35,35,36,35,34,35,34,34,35,34,35)
+  polar     T/F      : (34,34,35,36,34,36,35,34,35,35,35,36,35,34,35,34,35,35,34,36)
+  polar     T/T      : (34,36,35,34,34,36,35,34,36,35,35,36,35,34,35,34,34,35,34,35)
+  test_loop_point
+  linear+F  invariant: (17,16,17,16,17,17,17,17,16,17,17,17,17,16,16,17,17,16,17,17)
+  linear+F  forced   : (20,19,19,20,20,19,20,20,19,20,20,18,19,19,19,19,20,19,19,19)
+  linear+F  weak     : (21,19,20,20,20,19,24,20,19,25,24,18,19,19,19,19,20,19,19,19)
+  linear+F  flatten  : (19,19,21,20,20,20,20,20,19,19,19,21,19,20,19,19,19,19,19,20)
+  linear+F  careless : (19,19,19,19,20,19,20,20,19,20,18,18,19,18,19,19,19,19,19,19)
+  linear+F  binary   : (19,19,19,19,20,19,20,20,19,20,18,18,19,18,19,19,19,19,19,19)
+  linear-F  invariant: (17,17,17,18,18,18,21,17,16,17,19,18,17,18,23,17,18,17,19,17)
+  linear-F  forced   : (19,19,19,19,20,19,19,20,19,20,20,20,19,19,19,19,19,19,19,19)
+  linear-F  weak     : (19,19,20,19,20,19,19,20,19,21,20,20,21,19,19,19,20,19,19,19)
+  linear-F  flatten  : (20,19,20,20,21,19,20,18,19,19,20,21,19,21,20,19,19,19,19,20)
+  linear-F  careless : (20,19,19,21,19,19,20,17,19,20,19,20,19,19,19,19,19,19,19,20)
+  linear-F  binary   : (20,19,19,21,19,19,20,17,19,20,19,20,19,19,19,19,19,19,19,20)
+  mixed     invariant: (18,17,17,19,20,18,19,19,17,17,18,17,17,16,16,18,25,17,17,19)
+  mixed     forced   : (19,19,19,19,19,19,19,17,19,20,19,20,19,19,19,20,19,19,20,20)
+  mixed     weak     : (19,23,19,19,19,19,21,17,19,23,19,20,24,20,19,20,22,19,23,20)
+  mixed     flatten  : (20,19,19,20,19,19,19,18,20,20,19,18,18,19,18,20,19,19,19,19)
+  mixed     careless : (19,19,19,19,19,20,19,18,19,19,19,21,19,20,18,19,20,19,19,20)
+  mixed     binary   : (19,19,19,19,19,20,19,18,19,19,19,21,19,20,18,19,20,19,19,20)
+  Clifford  invariant: (32,34,31,34,33,36,31,35,32,33,32,36,32,34,33,36,33,32,34,34)
+  Clifford  forced   : (34,34,34,35,34,36,35,34,35,35,35,36,35,34,35,34,35,35,34,34)
+  Clifford  weak     : (34,34,34,35,34,36,35,34,35,35,35,36,35,34,35,34,35,35,34,34)
+  Clifford  flatten  : (34,34,34,35,34,36,35,34,36,35,34,36,36,34,35,34,35,35,34,34)
+  Clifford  careless : (3,1,3,2,2,2,2,2,2,3,2,2,3,2,2,3,2,2,1,3)
+  Clifford  binary   : (34,34,34,35,34,34,35,34,36,35,35,36,35,34,35,34,35,35,34,34)
+  Clifford  gyro     : (34,36,34,35,34,36,35,34,36,35,35,36,36,34,35,34,35,35,34,34)
+  halfplane invariant: (34,36,34,35,34,36,35,34,36,35,35,36,36,34,35,34,35,35,34,34)
+  polar     basic    : (34,34,34,35,34,34,33,34,36,35,35,24,36,34,35,34,35,35,34,34)
+  polar     improved : (34,34,34,34,33,36,35,33,36,35,35,36,35,34,35,34,34,35,34,35)
+  polar     F/F      : (34,36,35,35,33,34,33,33,36,35,35,36,36,34,35,34,35,35,34,34)
+  polar     F/T      : (34,34,34,34,33,36,35,33,36,35,35,36,35,34,35,34,34,35,34,35)
+  polar     T/F      : (34,34,35,36,34,36,35,34,35,35,35,36,35,34,35,34,35,35,34,36)
+  polar     T/T      : (34,36,35,34,34,36,35,34,36,35,35,36,35,34,35,34,34,35,34,35)
+  test_angledist
+  linear+F  invariant: (767,767,767)
+  linear+F  forced   : (21,21,21)
+  linear+F  weak     : (21,21,21)
+  linear+F  flatten  : (21,21,21)
+  linear+F  careless : (21,21,21)
+  linear+F  binary   : (21,21,21)
+  linear-F  invariant: (767,767,767)
+  linear-F  forced   : (21,21,21)
+  linear-F  weak     : (21,21,21)
+  linear-F  flatten  : (21,21,21)
+  linear-F  careless : (21,21,21)
+  linear-F  binary   : (21,21,21)
+  mixed     invariant: (767,767,767)
+  mixed     forced   : (21,21,21)
+  mixed     weak     : (21,21,21)
+  mixed     flatten  : (21,21,21)
+  mixed     careless : (21,21,21)
+  mixed     binary   : (21,21,21)
+  Clifford  invariant: (767,767,767)
+  Clifford  forced   : (39,39,47)
+  Clifford  weak     : (39,39,39)
+  Clifford  flatten  : (39,39,39)
+  Clifford  careless : (2,3,3)
+  Clifford  binary   : (39,47,39)
+  Clifford  gyro     : (39,47,39)
+  halfplane invariant: (767,767,767)
+  polar     basic    : (443,443,443)
+  polar     improved : (443,443,443)
+  polar     F/F      : (767,767,767)
+  polar     F/T      : (767,767,767)
+  polar     T/F      : (767,767,767)
+  polar     T/T      : (767,767,767)
+  test_similarity
+  linear+F  invariant: (18,17,17,18,17,18,18,17,18,17,18,18,17,17,17,18,17,17,17,17)
+  linear+F  forced   : (19,18,18,18,19,18,18,19,19,18,18,18,19,18,19,19,18,19,19,18)
+  linear+F  weak     : (19,18,18,18,19,18,18,19,19,18,18,18,19,18,19,19,18,19,19,18)
+  linear+F  flatten  : (18,19,18,18,18,19,19,19,19,18,18,18,19,18,19,19,19,19,18,19)
+  linear+F  careless : (19,18,19,18,19,18,18,19,19,18,18,18,19,19,19,19,18,18,19,18)
+  linear+F  binary   : (19,18,19,18,19,18,18,19,19,18,18,18,19,19,19,19,18,18,19,18)
+  linear-F  invariant: (18,18,19,18,18,18,18,18,18,18,18,19,19,19,18,18,19,18,18,18)
+  linear-F  forced   : (18,19,19,19,19,19,18,19,18,19,19,19,19,19,18,19,19,19,19,19)
+  linear-F  weak     : (18,19,19,19,19,19,18,19,18,19,19,19,19,19,18,19,19,19,19,19)
+  linear-F  flatten  : (19,18,19,19,19,19,19,19,18,19,19,19,19,19,18,19,19,19,19,19)
+  linear-F  careless : (18,19,19,19,19,19,19,19,18,19,19,19,19,19,19,19,19,19,19,19)
+  linear-F  binary   : (18,19,19,19,19,19,19,19,18,19,19,19,19,19,19,19,19,19,19,19)
+  mixed     invariant: (18,19,18,19,18,18,18,18,18,19,19,19,18,19,18,18,18,19,19,18)
+  mixed     forced   : (19,19,19,19,19,18,19,19,18,18,18,19,20,19,19,20,19,19,19,19)
+  mixed     weak     : (19,19,19,19,19,18,19,19,18,18,19,19,21,20,19,19,19,20,19,20)
+  mixed     flatten  : (19,19,19,19,19,19,19,19,20,18,19,19,19,19,20,19,19,19,19,19)
+  mixed     careless : (19,20,19,19,19,18,19,19,19,19,19,20,20,19,19,19,19,19,19,19)
+  mixed     binary   : (19,20,19,19,19,18,19,19,19,19,19,20,20,19,19,19,19,19,19,19)
+  Clifford  invariant: (33,33,33,32,32,34,34,33,32,34,33,33,34,33,33,33,33,34,33,33)
+  Clifford  forced   : (36,35,35,35,35,35,37,35,36,36,36,35,35,35,35,37,36,36,35,35)
+  Clifford  weak     : (36,35,35,35,35,35,37,35,36,36,36,35,35,35,35,37,36,36,35,35)
+  Clifford  flatten  : (35,37,36,35,36,35,35,38,36,37,36,35,37,35,37,38,36,38,35,36)
+  Clifford  careless : (37,35,36,35,35,36,35,35,37,35,38,36,38,35,37,36,35,35,35,37)
+  Clifford  binary   : (37,35,36,35,35,36,35,35,37,35,38,36,38,35,37,36,35,35,35,37)
+  Clifford  gyro     : (37,35,37,37,37,36,35,36,36,36,37,36,35,36,37,37,36,37,37,35)
+  halfplane invariant: (35,36,36,36,36,35,35,37,37,37,37,36,35,36,38,37,36,36,37,35)
+  polar     basic    : (19,18,18,18,19,18,18,18,18,18,18,18,18,19,18,18,18,18,18,18)
+  polar     improved : (37,37,37,37,37,38,38,37,37,36,37,37,38,39,38,37,37,39,37,38)
+  polar     F/F      : (19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19)
+  polar     F/T      : (35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35)
+  polar     T/F      : (19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19)
+  polar     T/T      : (35,35,35,35,35,36,35,35,35,36,36,35,35,35,35,35,35,35,35,36)
+  test_dissimilarity
+  linear+F  invariant: (125,124,147,123,134,130,126,128,123,125,130,130,127,125,125,131,123,124,125,127)
+  linear+F  forced   : (7,6,7,7,7,7,8,7,6,7,7,7,7,7,7,7,7,7,7,7)
+  linear+F  weak     : (7,7,7,7,9,13,8,7,9,7,9,7,7,7,11,9,7,8,7,7)
+  linear+F  flatten  : (7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7)
+  linear+F  careless : (7,7,7,7,7,7,7,7,6,7,8,7,7,7,7,7,7,7,7,7)
+  linear+F  binary   : (7,7,7,7,7,7,7,7,6,7,8,7,7,7,7,7,7,7,7,7)
+  linear-F  invariant: (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  linear-F  forced   : (10,10,10,10,10,10,10,10,10,9,9,10,10,10,10,10,10,9,10,10)
+  linear-F  weak     : (9,15,13,12,11,11,10,9,16,9,10,9,13,10,12,11,10,9,10,9)
+  linear-F  flatten  : (9,10,10,10,10,10,9,9,10,10,10,10,10,10,9,10,10,10,10,10)
+  linear-F  careless : (10,10,10,9,10,9,10,10,10,10,9,10,10,9,9,10,9,10,10,9)
+  linear-F  binary   : (10,10,10,9,10,9,10,10,10,10,9,10,10,9,9,10,9,10,10,9)
+  mixed     invariant: (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  mixed     forced   : (10,9,10,9,10,10,10,9,10,10,10,10,10,10,10,10,10,9,10,10)
+  mixed     weak     : (10,9,12,9,9,10,10,11,10,9,12,11,10,9,11,11,11,9,11,10)
+  mixed     flatten  : (10,9,10,10,9,10,10,10,10,10,10,10,10,10,9,10,10,10,10,10)
+  mixed     careless : (10,10,10,10,10,10,10,10,10,10,10,10,9,9,9,10,10,10,10,9)
+  mixed     binary   : (10,10,10,10,10,10,10,10,10,10,10,10,9,9,9,10,10,10,10,9)
+  Clifford  invariant: (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  Clifford  forced   : (18,19,18,18,19,18,19,18,19,19,18,19,18,17,19,19,19,19,19,19)
+  Clifford  weak     : (18,18,18,18,19,18,18,18,19,18,18,19,18,18,18,18,19,18,18,19)
+  Clifford  flatten  : (18,19,18,19,19,18,18,18,19,19,18,18,19,19,18,18,18,19,19,18)
+  Clifford  careless : (19,18,19,18,18,19,19,18,18,18,18,18,19,18,19,19,19,18,19,18)
+  Clifford  binary   : (19,18,19,18,18,19,19,18,18,18,18,18,19,18,19,19,19,18,19,18)
+  Clifford  gyro     : (18,18,18,19,19,18,19,20,18,18,18,18,18,19,19,19,18,19,18,18)
+  halfplane invariant: (35,35,35,35,35,35,35,35,34,36,37,34,35,36,35,35,35,35,36,35)
+  polar     basic    : (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  polar     improved : (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  polar     F/F      : (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  polar     F/T      : (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  polar     T/F      : (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  polar     T/T      : (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  test_other
+  linear+F  invariant: (97,97,101,107,97,97,126,107,101,101,112,112,99,101,112,131,107,97,97,94)
+  linear+F  forced   : (10,10,10,10,10,10,10,10,11,10,10,10,10,11,10,11,10,10,10,10)
+  linear+F  weak     : (10,11,10,11,12,13,11,11,13,14,10,10,10,11,11,11,12,10,13,10)
+  linear+F  flatten  : (10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,11,10)
+  linear+F  careless : (10,11,10,10,10,10,10,10,10,10,10,10,10,11,10,10,10,10,10,10)
+  linear+F  binary   : (10,11,10,10,10,10,10,10,10,10,10,10,10,11,10,10,10,10,10,10)
+  linear-F  invariant: (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  linear-F  forced   : (12,12,12,13,13,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12)
+  linear-F  weak     : (12,12,12,18,13,12,12,14,14,14,12,12,12,12,13,12,12,12,12,12)
+  linear-F  flatten  : (12,12,12,12,12,12,12,12,12,12,13,12,12,12,12,12,12,12,12,12)
+  linear-F  careless : (12,12,13,12,12,12,13,12,13,13,12,12,12,12,12,12,12,12,12,12)
+  linear-F  binary   : (12,12,13,12,12,12,13,12,13,13,12,12,12,12,12,12,12,12,12,12)
+  mixed     invariant: (359,360,359,359,359,359,359,359,359,359,359,359,359,359,360,359,359,359,359,359)
+  mixed     forced   : (14,13,14,14,13,13,13,14,13,14,14,14,14,13,14,13,13,14,13,13)
+  mixed     weak     : (13,13,14,14,13,13,13,14,13,18,13,16,14,13,15,14,13,14,13,13)
+  mixed     flatten  : (13,14,14,14,14,14,13,14,14,14,13,14,13,14,14,13,13,14,14,13)
+  mixed     careless : (14,13,14,14,13,14,14,14,14,14,14,14,13,14,13,14,13,14,13,13)
+  mixed     binary   : (14,13,14,14,13,14,14,14,14,14,14,14,13,14,13,14,13,14,13,13)
+  Clifford  invariant: (361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,361)
+  Clifford  forced   : (21,21,23,21,21,21,22,21,23,21,22,21,21,21,21,22,21,21,21,22)
+  Clifford  weak     : (21,21,23,21,21,21,22,21,23,21,21,21,21,21,21,22,21,21,21,22)
+  Clifford  flatten  : (21,21,22,21,22,22,21,23,21,21,22,22,22,22,22,21,21,22,22,22)
+  Clifford  careless : (21,22,22,21,21,22,22,23,21,21,21,22,22,21,21,21,22,22,22,23)
+  Clifford  binary   : (21,22,22,21,21,22,22,23,21,21,21,22,22,21,21,21,22,22,22,23)
+  Clifford  gyro     : (23,23,23,23,24,23,23,24,23,24,23,23,23,23,23,23,23,23,23,23)
+  halfplane invariant: (35,35,35,35,36,38,37,35,36,36,37,36,35,36,35,36,36,38,38,35)
+  polar     basic    : (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  polar     improved : (360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360)
+  polar     F/F      : (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  polar     F/T      : (360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360)
+  polar     T/F      : (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  polar     T/T      : (360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360)
+  test_walk
+  linear+F  invariant: (658,606,622,603,606,608,667,620,615,616,616,619,631,609,613,614,632,635,592,612)
+  linear+F  forced   : (632,617,606,617,608,607,607,628,627,632,626,627,596,652,623,639,615,617,615,616)
+  linear+F  weak     : (613,626,622,636,606,605,640,594,609,615,592,639,625,607,613,600,635,620,622,604)
+  linear+F  flatten  : (605,618,608,625,677,649,612,607,614,649,621,609,602,599,615,645,609,597,597,638)
+  linear+F  careless : (617,615,620,608,603,606,654,597,612,598,626,624,601,613,616,609,602,627,601,619)
+  linear+F  binary   : (617,615,620,608,603,606,654,597,612,598,626,624,601,613,616,609,602,627,601,619)
+  linear-F  invariant: (309,298,341,329,349,304,302,301,292,314,305,310,322,307,314,1315,1312,295,10000,10000)
+  linear-F  forced   : (1294,1290,1318,1308,1297,1287,1297,1295,1348,1304,1301,1309,1303,1318,292,1299,1294,1291,1288,1298)
+  linear-F  weak     : (298,295,301,289,299,289,287,301,297,294,305,297,316,286,292,291,301,293,303,299)
+  linear-F  flatten  : (297,1324,1299,1293,1315,1301,1313,1305,1305,306,1282,1310,1307,1309,1292,1306,1296,1315,1313,1289)
+  linear-F  careless : (1305,1310,1299,1298,1308,307,1318,1296,1293,1300,302,1306,1298,1287,1299,1315,1312,290,1290,1298)
+  linear-F  binary   : (1305,1310,1299,1298,1308,307,1318,1296,1293,1300,302,1306,1298,1287,1299,1315,1312,290,1290,1298)
+  mixed     invariant: (622,634,587,620,607,619,609,612,599,646,607,623,616,590,615,592,637,636,659,613)
+  mixed     forced   : (599,666,588,608,607,602,630,671,601,602,618,630,618,601,599,599,614,601,596,617)
+  mixed     weak     : (599,666,588,608,607,602,630,671,601,602,618,630,618,601,599,599,614,601,596,617)
+  mixed     flatten  : (611,616,607,605,610,603,595,605,593,614,617,593,602,642,610,616,625,593,636,617)
+  mixed     careless : (622,634,587,620,607,619,609,612,599,646,607,623,616,590,615,592,637,636,659,613)
+  mixed     binary   : (622,634,587,620,607,619,609,612,599,646,607,623,616,590,615,592,637,636,659,613)
+  Clifford  invariant: (622,634,587,620,607,619,609,612,599,646,607,623,616,590,615,592,637,636,659,613)
+  Clifford  forced   : (599,666,588,608,607,602,630,671,601,602,618,630,618,601,599,599,614,601,596,617)
+  Clifford  weak     : (599,666,588,608,607,602,630,671,601,602,618,630,618,601,599,599,614,601,596,617)
+  Clifford  flatten  : (611,616,607,605,610,603,595,605,593,614,617,593,602,642,610,616,625,593,636,617)
+  Clifford  careless : (622,634,587,620,607,619,609,612,599,646,607,623,616,590,615,592,637,636,659,613)
+  Clifford  binary   : (622,634,587,620,607,619,609,612,599,646,607,623,616,590,615,592,637,636,659,613)
+  Clifford  gyro     : (600,586,602,621,625,621,625,603,593,630,634,600,586,597,600,609,601,592,617,615)
+  halfplane invariant: (600,586,602,621,625,621,625,603,593,630,634,600,586,597,600,609,601,592,617,615)
+  polar     basic    : (1055,67,1078,66,72,1050,66,1073,70,1052,66,1070,66,67,71,73,1064,1070,67,66)
+  polar     improved : (71,1068,1073,1059,67,55,67,1071,65,1052,1067,1078,67,63,69,1067,57,66,69,1059)
+  polar     F/F      : (605,566,605,563,566,583,565,591,578,616,591,568,601,569,584,559,621,579,589,601)
+  polar     F/T      : (573,596,633,569,581,590,565,588,590,581,600,614,597,571,595,619,576,573,582,631)
+  polar     T/F      : (594,662,662,598,591,686,590,610,593,592,588,588,600,581,598,572,618,578,589,588)
+  polar     T/T      : (583,594,601,586,570,601,594,579,585,581,582,614,649,614,674,639,588,580,587,588)
+  test_close
+  linear+F  invariant: (0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,18,78,130,126,118)
+  linear+F  forced   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,11,70,110,118)
+  linear+F  weak     : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,11,70,110,118)
+  linear+F  flatten  : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,55,99,116)
+  linear+F  careless : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,67,107,113)
+  linear+F  binary   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,67,107,113)
+  linear-F  invariant: (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27,89,117,118)
+  linear-F  forced   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,73,117,117)
+  linear-F  weak     : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,73,117,116)
+  linear-F  flatten  : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,15,49,103,115)
+  linear-F  careless : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17,62,112,115)
+  linear-F  binary   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17,62,112,115)
+  mixed     invariant: (0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,36,101,117,115)
+  mixed     forced   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,21,72,114,117)
+  mixed     weak     : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,21,72,114,115)
+  mixed     flatten  : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,20,75,115,116)
+  mixed     careless : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,17,73,113,112)
+  mixed     binary   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,17,73,113,112)
+  Clifford  invariant: (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  Clifford  forced   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  Clifford  weak     : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  Clifford  flatten  : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  Clifford  careless : (1666,1698,1241,859,666,545,447,378,339,298,262,245,244,207,196,175,170,168,157,144)
+  Clifford  binary   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  Clifford  gyro     : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  halfplane invariant: (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  polar     basic    : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  polar     improved : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  polar     F/F      : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  polar     F/T      : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  polar     T/F      : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  polar     T/T      : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  test_count
+  linear+F  invariant: (spin(24A 34M 9D 4F) L0(24A 34M 9D 4F) L1(24A 34M 9D 4F) ip(9A 9M) ii(51A 51M 9D) d0(1F) angle(1F) inverse() push(29A 42M 10D 2F))
+  linear+F  forced   : (spin(27A 46M 9D 5F) L0(27A 46M 9D 5F) L1(27A 46M 9D 5F) ip(12A 15M 1F) ii(54A 73M 9D 3F) d0(1F) angle(1F) inverse() push(32A 54M 10D 3F))
+  linear+F  weak     : (spin(30A 49M 9D 5F) L0(30A 49M 9D 5F) L1(30A 49M 9D 5F) ip(12A 15M 1F) ii(57A 76M 9D 3F) d0(3A 4M 2F) angle(1F) inverse() push(38A 63M 10D 4F))
+  linear+F  flatten  : (spin(27A 37M 17D 4F) L0(27A 37M 17D 4F) L1(27A 37M 17D 4F) ip(9A 9M 2D) ii(54A 54M 17D) d0(3A 4M 2F) angle(1F) inverse() push(35A 51M 18D 3F))
+  linear+F  careless : (spin(27A 37M 9D 4F) L0(27A 37M 9D 4F) L1(27A 37M 9D 4F) ip(9A 9M) ii(54A 64M 9D 2F) d0(3A 4M 2F) angle(1F) inverse() push(35A 51M 10D 3F))
+  linear+F  binary   : (spin(27A 37M 9D 4F) L0(27A 37M 9D 4F) L1(27A 37M 9D 4F) ip(9A 9M) ii(54A 64M 9D 2F) d0(3A 4M 2F) angle(1F) inverse() push(35A 51M 10D 3F))
+  linear-F  invariant: (spin(2F) L0(2F) L1(2F) ip(9A 9M) ii(27A 27M) d0(1F) angle(1F) inverse() push(5A 8M 1D))
+  linear-F  forced   : (spin(3A 12M 3F) L0(3A 12M 3F) L1(3A 12M 3F) ip(12A 15M 1F) ii(30A 39M 1F) d0(1F) angle(1F) inverse() push(8A 20M 1D 1F))
+  linear-F  weak     : (spin(3A 12M 3F) L0(3A 12M 3F) L1(3A 12M 3F) ip(12A 15M 1F) ii(30A 39M 1F) d0(3A 4M 2F) angle(1F) inverse() push(11A 26M 1D 2F))
+  linear-F  flatten  : (spin(8D 2F) L0(8D 2F) L1(8D 2F) ip(9A 9M 2D) ii(27A 27M 8D) d0(3A 4M 2F) angle(1F) inverse() push(8A 14M 9D 1F))
+  linear-F  careless : (spin(2F) L0(2F) L1(2F) ip(9A 9M) ii(27A 27M) d0(3A 4M 2F) angle(1F) inverse() push(8A 14M 1D 1F))
+  linear-F  binary   : (spin(2F) L0(2F) L1(2F) ip(9A 9M) ii(27A 27M) d0(3A 4M 2F) angle(1F) inverse() push(8A 14M 1D 1F))
+  mixed     invariant: (spin(2F) L0(2F) L1(2F) ip(17A 24M) ii(12A 16M) d0(1F) angle(1F) inverse() push(5A 7M))
+  mixed     forced   : (spin(2F) L0(2F) L1(2F) ip(20A 30M 1F) ii(15A 28M 1F) d0(1F) angle(1F) inverse() push(7A 18M 1F))
+  mixed     weak     : (spin(2F) L0(2F) L1(2F) ip(20A 30M 1F) ii(15A 28M 1F) d0(3A 4M 2F) angle(1F) inverse() push(10A 24M 2F))
+  mixed     flatten  : (spin(1F) L0(1F) L1(1F) ip(17A 15M 2D) ii(12A 12M) d0(3A 4M 2F) angle(1F) inverse() push(8A 15M 1F))
+  mixed     careless : (spin(2F) L0(2F) L1(2F) ip(17A 24M) ii(12A 16M) d0(3A 4M 2F) angle(1F) inverse() push(8A 13M 1F))
+  mixed     binary   : (spin(2F) L0(2F) L1(2F) ip(17A 24M) ii(12A 16M) d0(3A 4M 2F) angle(1F) inverse() push(8A 13M 1F))
+  Clifford  invariant: (spin(2F) L0(2F) L1(2F) ip(12A 28M 1F) ii(12A 16M) d0(1F) angle(1F) inverse() push())
+  Clifford  forced   : (spin(2F) L0(2F) L1(2F) ip(13A 29M 1F) ii(15A 28M 1F) d0(1F) angle(1F) inverse() push())
+  Clifford  weak     : (spin(2F) L0(2F) L1(2F) ip(13A 29M 1F) ii(15A 28M 1F) d0(2A 4M 2F) angle(1F) inverse() push())
+  Clifford  flatten  : (spin(1F) L0(1F) L1(1F) ip(11A 20M) ii(12A 19M) d0(2A 4M 2F) angle(1F) inverse() push())
+  Clifford  careless : (spin(2F) L0(2F) L1(2F) ip(11A 18M) ii(12A 16M) d0(2A 4M 2F) angle(1F) inverse() push())
+  Clifford  binary   : (spin(2F) L0(2F) L1(2F) ip(11A 18M) ii(12A 16M) d0(2A 4M 2F) angle(1F) inverse() push())
+  Clifford  gyro     : (spin(2F) L0(2F) L1(2F) ip(5A 10M 2D) ii(4A 8M) d0(9A 12M 2D 5F) angle(7A 8M 2D 4F) inverse() push(11A 8M 2D 3F))
+  halfplane invariant: (spin(2F) L0(2F) L1(2F) ip(5A 10M 2D) ii(4A 8M) d0(8A 16M 2D 5F) angle(8A 16M 2D 5F) inverse() push(12A 16M 2D 4F))
+  polar     basic    : (spin(2F) L0() L1() ip(15A 25M 2D 12F) ii(53A 73M 2D 17F) d0() angle(1F) inverse(4A 4M) push())
+  polar     improved : (spin(2F) L0() L1() ip(20A 41M 2D 10F) ii(59A 88M 2D 15F) d0() angle(1F) inverse(4A 4M) push())
+  polar     F/F      : (spin() L0() L1() ip(5A 7M 14F) ii(10A 11M 21F) d0() angle() inverse(14A) push())
+  polar     F/T      : (spin() L0() L1() ip(5A 7M 14F) ii(14A 8M 18F) d0() angle() inverse(14A) push())
+  polar     T/F      : (spin() L0() L1() ip(5A 7M 14F) ii(11A 11M 21F) d0() angle() inverse(2A) push())
+  polar     T/T      : (spin() L0() L1() ip(5A 7M 14F) ii(15A 8M 18F) d0() angle() inverse(2A) push())
+```
+
+## Results on the {4,3,5} honeycomb
+
+```
+  test_loop_iso
+  linear+F  invariant: (32,32,34,34,41,39,60,43,32,31,38,36,36,36,41,50,33,37,33,53)
+  linear+F  forced   : (22,22,24,25,25,23,25,25,25,26,23,26,24,26,24,25,24,24,24,26)
+  linear+F  weak     : (24,25,26,25,28,26,25,25,27,25,23,27,27,27,27,26,24,24,27,26)
+  linear+F  flatten  : (22,22,24,25,25,23,27,26,25,26,25,26,24,26,26,26,24,24,24,26)
+  linear+F  careless : (26,25,26,25,25,26,27,25,26,26,23,26,27,27,26,26,25,24,27,26)
+  linear+F  binary   : (26,25,26,25,25,26,27,25,26,26,23,26,27,27,26,26,25,24,27,26)
+  linear-F  invariant: (35,72,27,37,38,43,27,25,29,44,24,47,26,27,28,29,42,35,29,29)
+  linear-F  forced   : (26,25,26,25,25,26,25,25,26,27,25,26,27,27,26,27,24,25,24,26)
+  linear-F  weak     : (31,25,30,25,26,29,25,25,26,27,25,26,29,27,27,27,24,31,24,26)
+  linear-F  flatten  : (22,22,26,25,25,23,25,26,25,26,23,24,24,26,24,27,24,24,24,26)
+  linear-F  careless : (22,22,24,25,26,23,25,25,25,26,23,24,27,26,24,26,24,24,27,26)
+  linear-F  binary   : (22,22,24,25,26,23,25,25,25,26,23,24,27,26,24,26,24,24,27,26)
+  mixed     invariant: (49,47,44,47,42,44,47,45,46,47,45,49,46,50,45,49,42,48,49,45)
+  mixed     forced   : (51,50,49,49,47,47,46,47,48,47,48,49,50,50,49,47,52,47,48,49)
+  mixed     weak     : (51,50,49,49,47,47,46,47,48,47,48,49,50,50,49,47,52,47,48,49)
+  mixed     flatten  : (1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1)
+  mixed     careless : (51,50,46,50,47,47,48,47,48,47,48,49,50,50,49,51,52,51,48,49)
+  mixed     binary   : (51,50,46,50,47,47,48,47,48,47,48,49,50,50,49,51,52,51,48,49)
+  Clifford  invariant: (46,47,44,44,42,44,47,45,45,46,45,50,46,50,45,39,42,44,49,45)
+  Clifford  forced   : (51,50,49,49,47,47,46,47,48,47,48,49,50,50,49,47,52,47,48,49)
+  Clifford  weak     : (51,50,49,49,47,47,46,47,48,47,48,49,50,50,49,47,52,47,48,49)
+  Clifford  flatten  : (55,78,999,58,57,81,55,79,98,999,58,51,66,52,99,51,58,54,88,66)
+  Clifford  careless : (51,50,46,50,47,47,48,47,48,47,48,49,50,50,49,51,52,51,48,49)
+  Clifford  binary   : (51,50,46,50,47,47,48,47,48,47,48,49,50,50,49,51,52,51,48,49)
+  Clifford  gyro     : (51,50,49,50,50,47,48,47,51,47,50,49,50,50,49,51,52,54,50,51)
+  halfplane invariant: (51,50,49,50,47,47,48,47,48,47,50,49,50,50,49,51,52,51,48,51)
+  polar     basic    : (12,50,46,49,47,47,48,47,48,3,46,49,50,50,47,7,52,3,48,49)
+  polar     improved : (49,46,49,50,50,47,48,47,51,47,50,49,50,50,49,51,48,51,48,49)
+  test_loop_point
+  linear+F  invariant: (999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999)
+  linear+F  forced   : (22,22,24,25,25,23,25,25,25,26,23,26,24,26,24,25,24,24,24,26)
+  linear+F  weak     : (24,25,26,25,28,26,25,25,27,25,23,27,27,27,27,26,24,24,27,26)
+  linear+F  flatten  : (22,22,24,25,25,23,27,26,25,26,25,27,24,26,26,26,24,24,24,26)
+  linear+F  careless : (26,25,26,25,25,26,27,25,26,26,23,26,27,27,26,26,25,24,27,26)
+  linear+F  binary   : (26,25,26,25,25,26,27,25,26,26,23,26,27,27,26,26,25,24,27,26)
+  linear-F  invariant: (35,72,27,37,38,43,27,25,29,44,24,47,26,27,28,29,42,35,29,29)
+  linear-F  forced   : (26,25,26,25,25,26,25,25,26,27,25,26,27,27,26,27,24,25,24,26)
+  linear-F  weak     : (31,25,30,25,26,29,25,25,26,27,25,26,29,27,27,27,24,31,24,26)
+  linear-F  flatten  : (22,22,26,25,25,23,25,26,25,26,23,24,24,26,24,27,24,24,24,26)
+  linear-F  careless : (22,22,24,25,26,23,25,25,25,26,23,24,27,26,24,26,24,24,27,26)
+  linear-F  binary   : (22,22,24,25,26,23,25,25,25,26,23,24,27,26,24,26,24,24,27,26)
+  mixed     invariant: (24,22,22,25,23,25,26,22,24,22,23,25,26,27,24,23,25,22,23,24)
+  mixed     forced   : (26,25,26,25,25,23,25,25,26,27,23,26,27,26,26,26,25,24,24,26)
+  mixed     weak     : (27,25,30,25,25,23,25,25,26,27,23,26,27,26,26,28,25,24,24,28)
+  mixed     flatten  : (1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1)
+  mixed     careless : (26,25,24,25,25,26,27,25,26,26,26,26,27,27,26,26,24,25,24,26)
+  mixed     binary   : (26,25,24,25,25,26,27,25,26,26,26,26,27,27,26,26,24,25,24,26)
+  Clifford  invariant: (46,45,48,44,42,44,45,48,47,48,46,41,45,49,48,39,50,48,51,45)
+  Clifford  forced   : (49,50,46,49,47,47,46,45,48,47,45,49,50,50,49,51,52,47,48,49)
+  Clifford  weak     : (49,50,46,49,47,47,46,45,48,47,45,49,50,50,49,51,52,47,48,49)
+  Clifford  flatten  : (50,48,46,49,47,46,48,47,48,47,45,47,50,50,49,47,42,47,48,49)
+  Clifford  careless : (3,3,1,2,2,2,2,2,3,3,3,2,3,2,1,2,3,3,1,3)
+  Clifford  binary   : (51,48,49,49,47,47,48,47,48,47,45,49,50,50,49,47,52,47,48,49)
+  Clifford  gyro     : (51,50,46,50,50,47,48,48,51,47,50,49,50,50,49,51,52,51,48,49)
+  halfplane invariant: (49,50,46,49,47,47,48,47,51,47,50,49,50,50,49,51,52,51,48,49)
+  polar     basic    : (12,50,46,49,47,47,48,47,48,3,46,49,50,50,47,7,52,3,48,49)
+  polar     improved : (49,46,49,50,50,47,48,47,51,47,50,49,50,50,49,51,48,51,48,49)
+  test_angledist
+  linear+F  invariant: (999,999,999)
+  linear+F  forced   : (26,26,32)
+  linear+F  weak     : (26,32,32)
+  linear+F  flatten  : (26,26,32)
+  linear+F  careless : (26,26,32)
+  linear+F  binary   : (26,26,32)
+  linear-F  invariant: (999,999,999)
+  linear-F  forced   : (26,26,32)
+  linear-F  weak     : (32,26,32)
+  linear-F  flatten  : (26,26,32)
+  linear-F  careless : (26,32,32)
+  linear-F  binary   : (26,32,32)
+  mixed     invariant: (999,999,999)
+  mixed     forced   : (26,26,32)
+  mixed     weak     : (26,26,32)
+  mixed     flatten  : (2,2,1)
+  mixed     careless : (26,26,32)
+  mixed     binary   : (26,26,32)
+  Clifford  invariant: (999,999,999)
+  Clifford  forced   : (57,57,47)
+  Clifford  weak     : (69,57,47)
+  Clifford  flatten  : (57,57,47)
+  Clifford  careless : (5,4,4)
+  Clifford  binary   : (57,57,47)
+  Clifford  gyro     : (57,69,57)
+  halfplane invariant: (999,999,999)
+  polar     basic    : (532,532,5)
+  polar     improved : (532,532,532)
+  test_similarity
+  linear+F  invariant: (17,16,16,16,16,16,17,16,17,16,17,17,16,16,16,17,17,16,16,17)
+  linear+F  forced   : (17,17,17,18,19,18,18,18,18,17,18,18,17,18,17,18,18,17,17,17)
+  linear+F  weak     : (17,17,17,18,18,18,18,18,17,17,18,18,17,18,17,18,17,17,17,17)
+  linear+F  flatten  : (17,17,17,18,18,18,18,18,17,17,18,18,17,18,17,18,18,17,17,17)
+  linear+F  careless : (17,17,17,18,19,18,17,18,17,17,18,18,17,18,17,17,18,17,17,17)
+  linear+F  binary   : (17,17,17,18,19,18,17,18,17,17,18,18,17,18,17,17,18,17,17,17)
+  linear-F  invariant: (17,18,18,17,17,17,17,18,17,18,17,18,17,18,17,17,17,17,17,17)
+  linear-F  forced   : (18,19,18,18,18,18,18,18,18,18,18,19,19,18,19,19,18,19,18,18)
+  linear-F  weak     : (18,19,18,18,18,17,18,18,18,18,19,19,19,18,19,19,18,19,18,18)
+  linear-F  flatten  : (19,18,19,18,18,18,18,20,18,19,18,18,20,19,19,19,18,19,18,18)
+  linear-F  careless : (19,18,18,18,19,18,18,20,19,18,18,19,19,19,18,18,19,18,18,18)
+  linear-F  binary   : (19,18,18,18,19,18,18,20,19,18,18,19,19,19,18,18,19,18,18,18)
+  mixed     invariant: (18,19,19,19,19,19,18,19,19,18,18,19,19,19,19,19,19,18,19,18)
+  mixed     forced   : (19,19,19,18,18,19,19,18,19,19,19,19,19,19,19,20,19,19,19,19)
+  mixed     weak     : (19,19,19,18,18,19,19,18,18,19,19,19,19,20,19,18,19,18,18,19)
+  mixed     flatten  : (19,19,18,19,19,18,19,20,18,19,19,20,19,19,20,18,19,19,19,20)
+  mixed     careless : (19,19,19,19,19,20,20,19,19,19,19,19,19,19,19,18,19,19,19,19)
+  mixed     binary   : (19,19,19,19,19,20,20,19,19,19,19,19,19,19,19,18,19,19,19,19)
+  Clifford  invariant: (34,33,34,35,33,34,33,32,34,34,33,34,34,34,34,35,33,34,33,34)
+  Clifford  forced   : (35,36,35,37,36,35,35,36,36,36,35,37,35,36,36,36,36,36,36,35)
+  Clifford  weak     : (35,36,35,37,36,35,35,36,36,36,35,37,35,36,36,36,36,36,36,35)
+  Clifford  flatten  : (35,36,35,35,36,36,37,37,36,36,36,36,36,36,38,35,37,36,37,36)
+  Clifford  careless : (36,36,38,36,37,35,35,37,36,36,37,35,37,35,35,35,35,37,36,38)
+  Clifford  binary   : (36,36,38,36,37,35,35,37,36,36,37,35,37,35,35,35,35,37,36,38)
+  Clifford  gyro     : (36,37,38,36,35,37,35,36,38,36,36,36,36,36,36,37,35,34,35,36)
+  halfplane invariant: (36,35,36,36,37,38,38,36,37,36,37,36,35,36,35,37,35,36,36,35)
+  polar     basic    : (17,18,18,17,17,17,17,18,18,18,17,17,17,18,17,17,17,17,17,17)
+  polar     improved : (34,37,35,36,37,36,34,36,35,35,35,34,36,35,36,36,35,35,35,35)
+  test_dissimilarity
+  linear+F  invariant: (63,63,64,75,63,63,64,64,64,64,63,63,73,66,63,63,76,74,64,64)
+  linear+F  forced   : (6,7,7,7,7,7,7,7,7,7,7,7,6,7,7,7,7,7,7,6)
+  linear+F  weak     : (7,9,8,8,7,8,8,7,13,8,7,8,6,7,7,8,8,7,8,7)
+  linear+F  flatten  : (8,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,6,7,7,7)
+  linear+F  careless : (7,7,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,6)
+  linear+F  binary   : (7,7,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,6)
+  linear-F  invariant: (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  linear-F  forced   : (10,10,10,10,10,10,10,10,10,10,10,9,9,10,9,10,10,9,10,9)
+  linear-F  weak     : (12,9,9,14,10,9,9,11,11,11,11,13,9,12,10,13,9,10,15,10)
+  linear-F  flatten  : (10,10,10,9,9,9,10,10,10,10,10,10,10,9,9,10,10,10,10,10)
+  linear-F  careless : (10,9,9,10,9,10,9,10,9,10,10,10,10,10,9,9,9,10,10,9)
+  linear-F  binary   : (10,9,9,10,9,10,9,10,9,10,10,10,10,10,9,9,9,10,10,9)
+  mixed     invariant: (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  mixed     forced   : (10,10,10,10,10,10,10,10,9,10,10,10,10,10,9,9,9,10,9,10)
+  mixed     weak     : (10,16,11,15,9,12,10,9,10,14,10,10,10,11,11,11,11,10,11,11)
+  mixed     flatten  : (9,10,9,10,10,10,9,10,9,10,10,10,10,9,10,9,10,9,9,9)
+  mixed     careless : (10,9,9,10,10,10,10,9,10,10,9,10,10,10,10,10,9,9,9,10)
+  mixed     binary   : (10,9,9,10,10,10,10,9,10,10,9,10,10,10,10,10,9,9,9,10)
+  Clifford  invariant: (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  Clifford  forced   : (18,17,17,19,20,17,18,18,19,19,18,18,17,19,18,18,19,18,19,18)
+  Clifford  weak     : (19,17,17,18,19,17,18,18,17,18,18,18,17,18,18,17,18,18,19,19)
+  Clifford  flatten  : (19,18,18,18,19,18,18,18,18,18,18,19,19,18,18,19,18,19,18,18)
+  Clifford  careless : (18,18,18,18,18,18,18,19,19,18,18,18,18,18,18,19,18,19,19,18)
+  Clifford  binary   : (18,18,18,18,18,18,18,19,19,18,18,18,18,18,18,19,18,19,19,18)
+  Clifford  gyro     : (18,17,18,19,19,19,18,19,18,19,18,18,19,19,19,19,18,18,19,17)
+  halfplane invariant: (34,35,36,35,35,35,35,34,35,35,36,35,35,37,36,37,35,35,34,35)
+  polar     basic    : (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  polar     improved : (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  test_other
+  linear+F  invariant: (73,50,65,68,65,50,68,50,64,67,65,63,50,66,63,50,68,50,64,67)
+  linear+F  forced   : (10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10)
+  linear+F  weak     : (10,10,11,10,11,17,10,12,13,12,11,11,10,10,10,11,11,16,10,14)
+  linear+F  flatten  : (10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10)
+  linear+F  careless : (10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10)
+  linear+F  binary   : (10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10)
+  linear-F  invariant: (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  linear-F  forced   : (12,12,13,12,12,12,12,12,12,12,12,13,12,12,12,12,12,12,12,12)
+  linear-F  weak     : (12,12,12,12,13,12,14,13,12,15,12,14,16,12,15,12,12,16,12,12)
+  linear-F  flatten  : (12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12)
+  linear-F  careless : (13,12,13,12,12,12,12,12,12,12,12,12,12,12,12,12,13,12,12,12)
+  linear-F  binary   : (13,12,13,12,12,12,12,12,12,12,12,12,12,12,12,12,13,12,12,12)
+  mixed     invariant: (359,359,359,359,359,359,359,359,359,359,359,359,359,359,359,359,359,359,359,359)
+  mixed     forced   : (14,14,14,13,14,13,14,13,14,14,13,14,14,13,13,14,13,14,14,13)
+  mixed     weak     : (15,13,14,13,14,14,16,13,16,14,14,14,13,13,13,14,13,13,14,15)
+  mixed     flatten  : (14,13,13,14,13,14,14,14,13,13,14,14,14,14,13,14,14,13,14,14)
+  mixed     careless : (14,14,13,13,13,13,13,13,14,14,13,14,14,13,13,14,13,13,14,13)
+  mixed     binary   : (14,14,13,13,13,13,13,13,14,14,13,14,14,13,13,14,13,13,14,13)
+  Clifford  invariant: (361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,361)
+  Clifford  forced   : (22,21,21,21,22,21,22,22,22,22,22,21,21,22,22,22,22,21,21,22)
+  Clifford  weak     : (22,21,21,21,22,21,22,22,22,22,22,21,21,22,22,22,22,21,21,22)
+  Clifford  flatten  : (22,22,22,22,22,22,22,22,22,22,22,21,21,22,22,22,22,22,22,22)
+  Clifford  careless : (22,21,22,22,22,23,21,21,21,22,22,21,22,21,22,22,22,22,22,22)
+  Clifford  binary   : (22,21,22,22,22,23,21,21,21,22,22,21,22,21,22,22,22,22,22,22)
+  Clifford  gyro     : (23,24,23,23,23,24,23,23,23,23,23,23,23,23,23,23,23,24,23,23)
+  halfplane invariant: (35,35,35,35,35,35,35,35,35,36,37,35,35,35,36,36,35,35,35,35)
+  polar     basic    : (356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356,356)
+  polar     improved : (360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360)
+  test_walk
+  linear+F  invariant: (614,576,600,601,581,579,609,600,596,565,596,610,583,588,595,606,591,592,579,614)
+  linear+F  forced   : (598,653,583,603,584,597,581,582,618,568,608,621,586,596,636,604,584,619,585,586)
+  linear+F  weak     : (606,604,616,593,604,592,583,611,598,576,597,579,603,584,575,591,584,587,600,591)
+  linear+F  flatten  : (619,599,580,615,608,615,600,593,601,577,615,603,579,590,635,589,589,586,560,589)
+  linear+F  careless : (620,596,575,593,602,591,576,587,603,574,596,604,589,615,599,623,586,620,612,602)
+  linear+F  binary   : (620,596,575,593,602,591,576,587,603,574,596,604,589,615,599,623,586,620,612,602)
+  linear-F  invariant: (293,291,289,304,1295,307,285,302,290,297,1311,289,320,292,305,289,285,2132,2137,284)
+  linear-F  forced   : (1292,288,1303,1298,301,1288,1285,1290,297,288,304,298,293,299,1300,1291,1294,1276,1281,1288)
+  linear-F  weak     : (288,288,284,300,301,291,286,294,297,288,304,288,293,299,300,286,291,10000,281,293)
+  linear-F  flatten  : (1292,1297,1303,1311,1292,1285,1296,1297,10000,1299,1321,298,1311,1288,293,1315,1287,1280,1283,1286)
+  linear-F  careless : (1288,1292,1288,303,1295,1295,1285,1303,291,1290,1310,289,1321,1290,1298,1289,1284,1276,1282,1287)
+  linear-F  binary   : (1288,1292,1288,303,1295,1295,1285,1303,291,1290,1310,289,1321,1290,1298,1289,1284,1276,1282,1287)
+  mixed     invariant: (592,582,592,572,580,598,589,597,594,567,595,600,605,591,602,611,596,580,589,587)
+  mixed     forced   : (592,587,597,579,582,627,592,603,603,565,596,576,589,591,596,606,592,594,591,592)
+  mixed     weak     : (592,587,597,579,582,627,592,603,603,565,596,576,589,591,596,606,592,594,591,592)
+  mixed     flatten  : (28,363,52,303,296,336,292,316,288,287,308,298,298,298,310,314,293,371,353,324)
+  mixed     careless : (592,582,592,572,580,598,589,597,594,567,595,600,605,591,602,611,596,580,589,587)
+  mixed     binary   : (592,582,592,572,580,598,589,597,594,567,595,600,605,591,602,611,596,580,589,587)
+  Clifford  invariant: (592,582,592,572,580,598,589,597,594,567,595,600,605,591,602,611,596,580,589,587)
+  Clifford  forced   : (592,587,597,579,582,627,592,603,603,565,596,576,589,591,596,606,592,594,591,592)
+  Clifford  weak     : (592,587,597,579,582,627,592,603,603,565,596,576,589,591,596,606,592,594,591,592)
+  Clifford  flatten  : (614,604,595,598,570,595,589,587,599,573,599,585,603,602,634,602,596,600,584,596)
+  Clifford  careless : (592,582,592,572,580,598,589,597,594,567,595,600,605,591,602,611,596,580,589,587)
+  Clifford  binary   : (592,582,592,572,580,598,589,597,594,567,595,600,605,591,602,611,596,580,589,587)
+  Clifford  gyro     : (601,581,606,584,595,604,609,589,582,596,601,601,579,601,619,589,588,583,588,587)
+  halfplane invariant: (576,614,594,596,580,604,594,600,610,566,593,584,603,597,606,608,588,579,575,590)
+  polar     basic    : (25,1047,69,1045,1045,1033,59,1065,1041,67,1064,56,1044,1034,70,68,55,53,53,55)
+  polar     improved : (55,58,70,1045,1045,1057,56,1065,59,68,1065,55,1044,1034,1070,66,1056,53,52,58)
+  test_close
+  linear+F  invariant: (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,4,22)
+  linear+F  forced   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  linear+F  weak     : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  linear+F  flatten  : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  linear+F  careless : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  linear+F  binary   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  linear-F  invariant: (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,8)
+  linear-F  forced   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  linear-F  weak     : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  linear-F  flatten  : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  linear-F  careless : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1)
+  linear-F  binary   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1)
+  mixed     invariant: (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1)
+  mixed     forced   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1)
+  mixed     weak     : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1)
+  mixed     flatten  : (5000,2716,1760,1229,986,774,667,584,500,460,430,365,344,299,286,283,257,237,231,234)
+  mixed     careless : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  mixed     binary   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  Clifford  invariant: (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  Clifford  forced   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  Clifford  weak     : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  Clifford  flatten  : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  Clifford  careless : (1666,1539,1427,1047,817,653,547,483,418,381,350,308,283,260,247,230,212,202,188,183)
+  Clifford  binary   : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  Clifford  gyro     : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  halfplane invariant: (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  polar     basic    : (0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  polar     improved : (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+  test_count
+  linear+F  invariant: (spin(60A 78M 24D 5F) L0(60A 78M 24D 5F) L1(60A 78M 24D 5F) ip(16A 16M) ii(124A 142M 24D 3F) d0(1F) angle(1F) inverse() push(70A 96M 25D 3F))
+  linear+F  forced   : (spin(64A 98M 24D 6F) L0(64A 98M 24D 6F) L1(64A 98M 24D 6F) ip(20A 24M 1F) ii(128A 162M 24D 4F) d0(1F) angle(1F) inverse() push(74A 116M 25D 4F))
+  linear+F  weak     : (spin(68A 102M 24D 6F) L0(68A 102M 24D 6F) L1(68A 102M 24D 6F) ip(20A 24M 1F) ii(132A 166M 24D 4F) d0(4A 5M 2F) angle(1F) inverse() push(82A 128M 25D 5F))
+  linear+F  flatten  : (spin(64A 82M 39D 5F) L0(64A 82M 39D 5F) L1(64A 82M 39D 5F) ip(16A 16M 3D) ii(128A 146M 39D 3F) d0(4A 5M 2F) angle(1F) inverse() push(78A 108M 40D 4F))
+  linear+F  careless : (spin(64A 82M 24D 5F) L0(64A 82M 24D 5F) L1(64A 82M 24D 5F) ip(16A 16M) ii(128A 146M 24D 3F) d0(4A 5M 2F) angle(1F) inverse() push(78A 108M 25D 4F))
+  linear+F  binary   : (spin(64A 82M 24D 5F) L0(64A 82M 24D 5F) L1(64A 82M 24D 5F) ip(16A 16M) ii(128A 146M 24D 3F) d0(4A 5M 2F) angle(1F) inverse() push(78A 108M 25D 4F))
+  linear-F  invariant: (spin(2F) L0(2F) L1(2F) ip(16A 16M) ii(64A 64M) d0(1F) angle(1F) inverse() push(10A 18M 1D))
+  linear-F  forced   : (spin(4A 20M 3F) L0(4A 20M 3F) L1(4A 20M 3F) ip(20A 24M 1F) ii(68A 84M 1F) d0(1F) angle(1F) inverse() push(14A 38M 1D 1F))
+  linear-F  weak     : (spin(4A 20M 3F) L0(4A 20M 3F) L1(4A 20M 3F) ip(20A 24M 1F) ii(68A 84M 1F) d0(4A 5M 2F) angle(1F) inverse() push(18A 46M 1D 2F))
+  linear-F  flatten  : (spin(15D 2F) L0(15D 2F) L1(15D 2F) ip(16A 16M 3D) ii(64A 64M 15D) d0(4A 5M 2F) angle(1F) inverse() push(14A 26M 16D 1F))
+  linear-F  careless : (spin(2F) L0(2F) L1(2F) ip(16A 16M) ii(64A 64M) d0(4A 5M 2F) angle(1F) inverse() push(14A 26M 1D 1F))
+  linear-F  binary   : (spin(2F) L0(2F) L1(2F) ip(16A 16M) ii(64A 64M) d0(4A 5M 2F) angle(1F) inverse() push(14A 26M 1D 1F))
+  mixed     invariant: (spin(2F) L0(2F) L1(2F) ip(52A 64M) ii(56A 64M) d0(1F) angle(1F) inverse() push(7A 10M))
+  mixed     forced   : (spin(2F) L0(2F) L1(2F) ip(56A 72M 1F) ii(63A 88M 1F) d0(1F) angle(1F) inverse() push(10A 30M 1F))
+  mixed     weak     : (spin(2F) L0(2F) L1(2F) ip(56A 72M 1F) ii(63A 88M 1F) d0(4A 5M 2F) angle(1F) inverse() push(14A 38M 2F))
+  mixed     flatten  : (spin(1F) L0(1F) L1(1F) ip(52A 49M 3D) ii(56A 56M) d0(4A 5M 2F) angle(1F) inverse() push(11A 21M 1F))
+  mixed     careless : (spin(2F) L0(2F) L1(2F) ip(52A 64M) ii(56A 64M) d0(4A 5M 2F) angle(1F) inverse() push(11A 18M 1F))
+  mixed     binary   : (spin(2F) L0(2F) L1(2F) ip(52A 64M) ii(56A 64M) d0(4A 5M 2F) angle(1F) inverse() push(11A 18M 1F))
+  Clifford  invariant: (spin(2F) L0(2F) L1(2F) ip(39A 68M 1F) ii(56A 64M) d0(1F) angle(1F) inverse() push())
+  Clifford  forced   : (spin(2F) L0(2F) L1(2F) ip(39A 68M 1F) ii(63A 88M 1F) d0(1F) angle(1F) inverse() push())
+  Clifford  weak     : (spin(2F) L0(2F) L1(2F) ip(39A 68M 1F) ii(63A 88M 1F) d0(3A 5M 2F) angle(1F) inverse() push())
+  Clifford  flatten  : (spin(1F) L0(1F) L1(1F) ip(36A 51M) ii(56A 71M) d0(3A 5M 2F) angle(1F) inverse() push())
+  Clifford  careless : (spin(2F) L0(2F) L1(2F) ip(36A 48M) ii(56A 64M) d0(3A 5M 2F) angle(1F) inverse() push())
+  Clifford  binary   : (spin(2F) L0(2F) L1(2F) ip(36A 48M) ii(56A 64M) d0(3A 5M 2F) angle(1F) inverse() push())
+  Clifford  gyro     : (spin(8A 1F) L0(8A 1F) L1(8A 1F) ip(23A 38M 1D) ii(24A 32M) d0(23A 26M 1D 5F) angle(20A 21M 1D 4F) inverse() push(28A 21M 1D 3F))
+  halfplane invariant: (spin(8A 2F) L0(8A 2F) L1(8A 2F) ip(23A 38M 1D) ii(24A 32M) d0(23A 38M 1D 5F) angle(23A 38M 1D 5F) inverse() push(31A 38M 1D 4F))
+  polar     basic    : (spin(2F) L0() L1() ip(24A 35M 3D 12F) ii(114A 135M 3D 17F) d0() angle(1F) inverse(9A 9M) push())
+  polar     improved : (spin(2F) L0() L1() ip(29A 51M 3D 10F) ii(120A 150M 3D 15F) d0() angle(1F) inverse(9A 9M) push())
+```

devmods/reps/tests.cpp

@@ -0,0 +1,538 @@
+namespace reps {
+
+constexpr int test_dim = 3;
+constexpr bool in_hyperbolic = true;
+
+int edges, valence;
+
+void prepare_tests() {
+  hr::start_game();
+  if(MDIM != test_dim) throw hr::hr_exception("fix your dimension");
+  if(!(in_hyperbolic ? hyperbolic : sphere)) throw hr::hr_exception("fix your geometry");
+  if(hr::variation != hr::eVariation::pure) throw hr::hr_exception("fix your variation"); 
+  if(quotient) throw hr::hr_exception("fix your quotient");
+  if(test_dim == 4) {
+    if(cginf.tiling_name != "{4,3,5}") throw hr::hr_exception("only {4,3,5} implemented in 3D");
+    edges = 4;
+    valence = 5;
+    }
+  else {
+    edges = hr::cwt.at->type;
+    bool ok;
+    valence = hr::get_valence(hr::cwt.at, 1, ok);
+    }
+  }
+
+struct data {
+  using Number = hr::ld;
+  static constexpr int Dim = test_dim;
+  static constexpr int Flipped = in_hyperbolic ? test_dim-1 : -1;
+  };
+
+struct countdata {
+  using Number = countfloat;
+  static constexpr int Dim = data::Dim;
+  static constexpr int Flipped = data::Flipped;
+  };
+
+struct bigdata {
+  using Number = big;
+  static constexpr int Dim = data::Dim;
+  static constexpr int Flipped = data::Flipped;
+  };
+
+using good = rep_linear_nn<bigdata>;
+
+int debug; // 0 -- never, 1 -- only errors, 2 -- always
+
+vector<cell*> randomwalk(std::mt19937& gen, cell *from, int dist) {
+  vector<cell*> res = { from };
+  while(celldistance(from, res.back()) < dist) {
+    int i = gen() % res.back()->type;
+    res.push_back(res.back()->cmove(i));
+    }
+  return res;
+  }
+
+template<class N> N rand01(std::mt19937& gen) { return N(((gen() & HRANDMAX) | 1) / (HRANDMAX+1.)); }
+
+vector<cell*> random_return(std::mt19937& gen, cell *from, cell *to, ld peq, ld pbad) {
+  vector<cell*> res = { from };
+  ld d = celldistance(to, from);
+  while(to != res.back()) {
+    int i = gen() % res.back()->type;
+    cell *r1 = res.back()->cmove(i);
+    ld d1 = celldistance(to, r1);
+    bool ok = d1 < d ? true : d1 == d ? rand01<ld>(gen) < peq : rand01<ld>(gen) < pbad;
+    if(ok) { res.push_back(r1); d = d1; }
+    }
+  return res;
+  }
+
+vector<cell*> vrev(vector<cell*> a) { reverse(a.begin(), a.end()); return a; }
+vector<cell*> vcon(vector<cell*> a, vector<cell*> b) { for(auto bi: b) a.push_back(bi); return a; }
+
+template<class N> N edge_of_triangle_with_angles(N alpha, N beta, N gamma) {
+  N of = (cos(alpha) + cos(beta) * cos(gamma)) / (sin(beta) * sin(gamma));
+  if(hyperbolic) return acosh(of);
+  return acos(of);
+  }
+
+template<class N> N get_edgelen() {
+  N beta = get_deg<N>(360)/valence;
+  return edge_of_triangle_with_angles<N> (beta, get_deg<N>(180)/edges, get_deg<N>(180)/edges);
+  }
+
+template<class T> typename T::isometry cpush(int c, typename T::data::Number distance) {
+  return T::lorentz(c, T::data::Dim-1, distance);
+  }
+
+template<class T> struct cube_rotation_data_t {
+  std::vector<std::pair<hr::transmatrix, typename T::isometry>> mapping;
+  };
+
+template<class T> cube_rotation_data_t<T> cube_rotation_data;
+
+template<class T> cube_rotation_data_t<T>& build_cube_rotation() {
+  auto& crd = cube_rotation_data<T>;
+  auto& crdm = crd.mapping;
+  // using N = typename T::data::Number;
+  if(crdm.empty()) {
+    crdm.emplace_back(hr::Id, T::id());
+    for(int i=0; i<isize(crdm); i++) 
+    for(int j=0; j<3; j++) for(int k=0; k<3; k++) if(j != k) {
+      hr::transmatrix U = crdm[i].first * hr::cspin90(j, k);
+      bool is_new = true;
+      for(int i0=0; i0<isize(crdm); i0++) if(hr::eqmatrix(U, crdm[i0].first)) is_new = false;
+      // if(is_new) crdm.emplace_back(U, T::apply(crdm[i].second, T::cspin(j, k, get_deg<N>(90))));
+      if(is_new) crdm.emplace_back(U, T::apply(crdm[i].second, T::cspin90(j, k)));
+      }
+    if(isize(crdm) != 24) {
+      println(hlog, "the number of rotations found: ", isize(crdm));
+      throw hr::hr_exception("wrong number of rotations");
+      }
+    }
+  return crd;
+  }
+
+template<class T, class U> U apply_move(cell *a, cell *b, U to) {
+  if(a == b) return to;
+  using N = typename T::data::Number;
+  if constexpr(test_dim == 4) {
+    auto& crdm = build_cube_rotation<T>().mapping;
+    int ida = neighborId(a, b);
+    auto M = hr::currentmap->adj(a, ida);
+    for(int i0=0; i0<isize(crdm); i0++)
+    for(int i1=0; i1<isize(crdm); i1++)
+      if(hr::eqmatrix(M, crdm[i0].first * hr::xpush(1.06128) * crdm[i1].first)) {
+        to = T::apply(crdm[i1].second, to);
+        to = T::apply(cpush<T>(0, get_edgelen<N>()), to);
+        to = T::apply(crdm[i0].second, to);
+        return to;
+        }
+    println(hlog, "tessf = ", hr::cgip->tessf);
+    println(hlog, "len = ", get_edgelen<N>());
+    throw hr::hr_exception("rotation not found");
+    }
+  int ida = neighborId(a, b);
+  int idb = neighborId(b, a);
+  auto P1 = T::cspin(0, 1, idb * get_deg<N>(360) / edges);
+  to = T::apply(P1, to);
+  auto P2 = cpush<T>(0, get_edgelen<N>());
+  to = T::apply(P2, to);
+  auto P3 = T::cspin(1, 0, get_deg<N>(180) + ida * get_deg<N>(360) / edges);
+  to = T::apply(P3, to);
+  return to;
+  }
+
+template<class T, class U> U apply_path(vector<cell*> path, U to) {
+  for(int i=hr::isize(path)-2; i>=0; i--)
+    to = apply_move<T, U> (path[i], path[i+1], to);
+  return to;
+  }
+
+template<class T> double test_sanity(int i) {
+  hr::indenter in(2);
+
+  ld d1 = 1.25, d2 = 1.5;
+
+  typename good::point gp = good::center();
+  gp = good::apply(cpush<good>(0, d1), gp);
+  gp = good::apply(cpush<good>(1, d2), gp);
+  gp = good::apply(good::cspin(0, 1, get_deg<big>(72)), gp);
+
+  typename T::point p = T::center();
+  p = T::apply(cpush<T>(0, d1), p);
+  p = T::apply(cpush<T>(1, d2), p);
+  p = T::apply(T::cspin(0, 1, get_deg<typename T::data::Number>(72)), p);
+
+  double res = 0;
+  #define ADD(x, y) if(debug) println(hlog, "VS ", x, ",", y); res += pow( double(x-y), 2);
+  #define ADDA(x, y) if(debug) println(hlog, "VS ", x, ",", y); res += pow( cyclefix_on(double(x-y)), 2);
+
+  if(debug) println(hlog, "p=", T::print(p));
+
+  ADD(T::get_coord(p, 0), good::get_coord(gp, 0));
+  ADD(T::get_coord(p, 1), good::get_coord(gp, 1));
+  ADD(T::get_coord(p, 2), good::get_coord(gp, 2));
+  ADD(T::dist0(p), good::dist0(gp));
+  ADDA(T::angle(p), good::angle(gp));
+
+  return res;
+  }
+
+template<class T> double test_consistency(int i) {
+  double res = 0;
+  using D = typename T::data;
+
+  auto a = cpush<T>(0, 1);
+  auto b = cpush<T>(1, 1);
+  auto c = cpush<T>(0, 1);
+
+  auto s   = T::apply(T::apply(a, b), c);
+  auto sp  = T::apply(s, T::center());
+  auto s1  = T::apply(a, T::apply(b, c));
+  auto sp1 = T::apply(s1, T::center());
+  auto sp2 = T::apply(a, T::apply(b, T::apply(c, T::center())));
+  ADD(T::dist0(sp), T::dist0(sp1));
+  ADD(T::dist0(sp), T::dist0(sp2));
+  for(int i=0; i<D::Dim; i++) { ADD(T::get_coord(sp, i), T::get_coord(sp1, i)); }
+  for(int i=0; i<D::Dim; i++) { ADD(T::get_coord(sp, i), T::get_coord(sp2, i)); }
+  if(test_dim == 3) {
+    ADDA(T::angle(sp), T::angle(sp1));
+    ADDA(T::angle(sp), T::angle(sp2));
+    }
+
+  return res;
+  }
+
+template<class T> double test_tba(int id) {
+  std::mt19937 testr; testr.seed(id);
+  for(int i=0; i<hr::cwt.at->type; i++) {
+    vector<cell*> p = {hr::cwt.at, hr::cwt.at->cmove(i), hr::cwt.at};
+    auto h = apply_path<T>(p, T::center());
+    if(debug == 2) println(hlog, "i=", hr::lalign(3, i), " h = ", T::print(h), " distance =", T::dist0(h));
+    if(T::dist0(h) >= 0 && T::dist0(h) < 0.1) continue;
+    exit(1);
+    }
+  return 999;
+  }
+
+template<class T> double test_loop_point(int id) {
+  std::mt19937 testr; testr.seed(id);
+  for(int i=0; i<100; i++) {
+    auto p1 = randomwalk(testr, hr::cwt.at, i);
+    auto p2 = random_return(testr, p1.back(), hr::cwt.at, 1/16., 1/32.);
+    auto p = vcon(p1, p2);
+    if(debug == 2) println(hlog, "path = ", p);
+    auto h = apply_path<T>(vrev(p), T::center());
+    if(debug == 2) println(hlog, "i=", hr::lalign(3, i), " h = ", T::print(h), " distance =", T::dist0(h));
+    if(T::dist0(h) >= 0 && T::dist0(h) < 0.1) continue;
+    return i;
+    }
+  return 999;
+  }
+
+template<class T> double test_loop_iso(int id) {
+  std::mt19937 testr; testr.seed(id);
+  for(int i=0; i<100; i++) {
+    auto p1 = randomwalk(testr, hr::cwt.at, i);
+    auto p2 = random_return(testr, p1.back(), hr::cwt.at, 1/16., 1/32.);
+    auto p = vcon(p1, p2);
+    if(debug == 2) println(hlog, "path = ", p);
+    auto h = apply_path<T>(vrev(p), T::id());
+    auto hr = T::apply(h, T::center());
+    // println(hlog, "i=", hr::lalign(3, i), " h=", hr);
+    if(debug == 2) println(hlog, "i=", hr::lalign(3, i), " hr = ", T::print(hr), " distance = ", T::dist0(hr));
+    if(T::dist0(hr) >= 0 && T::dist0(hr) < 0.1) continue;
+    if(debug == 1) println(hlog, "i=", hr::lalign(3, i), " hr = ", T::print(hr), " distance = ", T::dist0(hr));
+    return i;
+    }
+  return 999;
+  }
+
+template<class T, class F> vector<T> repeat_test(const F& f, int qty) {
+  vector<T> res;
+  for(int i=0; i<qty; i++) res.push_back(f(i));
+  return res;
+  }
+
+template<class T> typename T::isometry random_rotation(std::mt19937& testr) {
+  using D = typename T::data;
+  using N = typename D::Number;
+
+  if(D::Dim == 3) {
+    auto alpha = rand01<N>(testr) * get_deg<N>(360);
+    return T::cspin(0, 1, alpha);
+    }
+
+  auto x = T::id();
+  for(int i=0; i<100; i++) {
+    int c0 = testr() % (D::Dim-1);
+    int c1 = testr() % (D::Dim-1);
+    if(c0 == c1) continue;
+    auto len = rand01<N>(testr) * get_deg<N>(360);
+    x = T::apply(T::cspin(c0, c1, len), x);
+    }
+  return x;
+  }
+
+template<class T> typename T::isometry random_iso(std::mt19937& testr) {
+  auto x = T::id();
+  using D = typename T::data;
+  using N = typename D::Number;
+  for(int i=0; i<100; i++) {
+    int c0 = testr() % D::Dim;
+    int c1 = testr() % D::Dim;
+    if(c0 == c1) continue;
+    if(c0 == D::Flipped) std::swap(c0, c1);
+    N len = c1 < D::Flipped ? rand01<N>(testr) * get_deg<N>(360) : (rand01<N>(testr)-N(0.5)) * N(0.25);
+    if(c1 == D::Flipped) x = T::apply(T::lorentz(c0, c1, len), x);
+    else x = T::apply(T::cspin(c0, c1, len), x);
+    }
+  return x;
+  }
+
+
+template<class T> std::string test_count(int id) {
+  std::mt19937 testr; testr.seed(id);
+  hr::shstream out;
+  auto A = random_iso<T>(testr);
+  auto B = random_iso<T>(testr);
+  auto C = random_iso<T>(testr);
+  auto P = T::apply(C, T::center());
+  for(int i=0; i<9; i++) {
+    counts.clear();
+    for(auto& i: cbc) i = 0;
+    std::string s;
+    switch(i) {
+      case 0: s = "spin"; T::cspin(0, 1, countfloat(.5)); break;
+      case 1: s = "L0"; T::lorentz(0, T::data::Dim-1, countfloat(.5)); break;
+      case 2: s = "L1"; T::lorentz(1, T::data::Dim-1, countfloat(.5)); break;
+      case 3: s = "ip"; T::apply(A, P); break;
+      case 4: s = "ii"; T::apply(A, B); break;
+      case 5: s = "d0"; T::dist0(P); break;
+      case 6: s = "angle"; T::angle(P); break;
+      case 7: s = "inverse"; T::inverse(A); break;
+      case 8: s = "push"; T::push(P); break;
+      }
+    if(i) print(out, " ");
+    if(1) {
+      print(out, s, "(");
+      bool nsp = false;
+      for(int i=1; i<5; i++) if(cbc[i]) {
+        if(nsp) print(out, " ");
+        print(out, cbc[i], hr::s0+".AMDF"[i]);
+        nsp = true;
+        }
+      print(out, ")");
+      }
+    }
+  return out.s;
+  }
+
+template<class A, class B> bool closeto(A a, B b) { return abs(a-b) < 0.1; }
+
+template<class A, class B> bool closeto_angle(A a, B b) { return abs(cyclefix_on(double(a-b))) < 0.1; }
+
+template<class T> double test_angledist(int id) {
+  std::mt19937 testr; testr.seed(id);
+  for(int i=1; i<1000; i += (1 + i/5)) {
+
+    auto p = randomwalk(testr, hr::cwt.at, i);
+    auto h = apply_path<T>(vrev(p), T::center());
+
+    auto gh = apply_path<good>(vrev(p), good::center());
+
+    if(debug == 2) {
+      println(hlog, "good: ", good::print(gh), " dist = ", good::dist0(gh), " angle = ", good::angle(gh));
+      println(hlog, "test: ", T::print(h), " dist = ", T::dist0(h), " angle = ", T::angle(h), " [i=", i, "]");
+      }
+
+    if(closeto(good::dist0(gh), T::dist0(h)) && closeto_angle(good::angle(gh), T::angle(h))) continue;
+
+    if(debug == 1) {
+      println(hlog, "good: ", good::print(gh), " dist = ", good::dist0(gh), " angle = ", good::angle(gh));
+      println(hlog, "test: ", T::print(h), " dist = ", T::dist0(h), " angle = ", T::angle(h), " [i=", i, "]");
+      }
+
+    return i;
+    }
+  return 999;
+  }
+
+#define TEST_VARIANTS(x,D,q,t,rn, r) \
+  nm = nmInvariant; println(hlog, rn, "invariant: ", repeat_test<t>(x<r<D>>, q));  \
+  nm = nmForced;    println(hlog, rn, "forced   : ", repeat_test<t>(x<r<D>>, q));   \
+  nm = nmWeak;      println(hlog, rn, "weak     : ", repeat_test<t>(x<r<D>>, q));    \
+  nm = nmFlatten;   println(hlog, rn, "flatten  : ", repeat_test<t>(x<r<D>>, q));     \
+  nm = nmCareless;  println(hlog, rn, "careless : ", repeat_test<t>(x<r<D>>, q));      \
+  nm = nmBinary;    println(hlog, rn, "binary   : ", repeat_test<t>(x<r<D>>, q));
+
+/*
+#define TEST_ALL(x,D,q,t) \
+  println(hlog, "HyperRogue: ", repeat_test<t>(x<rep_hr<D>>, q));                                             \
+  polar_mod = polar_choose = false;  println(hlog, "high polar: ", repeat_test<t>(x<rep_high_polar<D>>, q));   \
+  if(test_dim == 3) { polar_mod = polar_choose = false;  println(hlog, "low polar : ", repeat_test<t>(x<rep_polar2<D>>, q)); }
+*/
+
+//                    println(hlog, "HyperRogue         : ", repeat_test<t>(x<rep_hr<D>>, q));                     
+
+#define TEST_ALL(x,D,q,t) \
+  fix_matrices = true;  TEST_VARIANTS(x,D,q,t,"linear+F  ", rep_linear)                                           \
+  fix_matrices = false; TEST_VARIANTS(x,D,q,t,"linear-F  ", rep_linear)                                            \
+  TEST_VARIANTS(x,D,q,t,"mixed     ", rep_mixed)                                                                    \
+  TEST_VARIANTS(x,D,q,t,"Clifford  ", rep_clifford)                                                                  \
+  nm = nmFlatten; println(hlog, "Clifford  gyro     : ", repeat_test<t>(x<rep_half<D>>, q));                          \
+  nm = nmInvariant; println(hlog, "halfplane invariant: ", repeat_test<t>(x<rep_half<D>>, q));                         \
+  polar_choose = false;  println(hlog, "polar     basic    : ", repeat_test<t>(x<rep_high_polar<D>>, q));               \
+  polar_choose = true;   println(hlog, "polar     improved : ", repeat_test<t>(x<rep_high_polar<D>>, q));                \
+  if(test_dim == 3) {                                                                                                     \
+    polar_mod = false; polar_choose = false;  println(hlog, "polar     F/F      : ", repeat_test<t>(x<rep_polar2<D>>, q)); \
+    polar_mod = false; polar_choose = true;   println(hlog, "polar     F/T      : ", repeat_test<t>(x<rep_polar2<D>>, q));  \
+    polar_mod = true;  polar_choose = false;  println(hlog, "polar     T/F      : ", repeat_test<t>(x<rep_polar2<D>>, q));   \
+    polar_mod = true;  polar_choose = true;   println(hlog, "polar     T/T      : ", repeat_test<t>(x<rep_polar2<D>>, q));    \
+    }
+
+template<class T> double test_distances(int id, int a) {
+  std::mt19937 testr; testr.seed(id);
+  using N = typename T::data::Number;
+
+  for(int i=1; i<1000; i ++) {
+
+    auto R = random_rotation<T>(testr);
+    auto dif = exp(N(-1) * i) + get_deg<N>(a);
+
+    auto p1 = T::apply(T::apply(R, cpush<T>(0, N(i))), T::center());
+    auto p2 = T::apply(T::apply(R, T::apply(T::cspin(0, 1, dif), cpush<T>(0, N(i)))), T::center());
+    auto pd = T::apply(T::inverse(T::push(p1)), p2);
+    auto d = T::dist0(pd);
+
+    // for good we do not need R actually
+    auto gp1 = good::apply(cpush<good>(0, N(i)), good::center());
+    auto gp2 = good::apply(good::apply(good::cspin(0, 1, dif), cpush<good>(0, N(i))), good::center());
+    auto gd = good::dist0(good::apply(good::inverse(good::push(gp1)), gp2));
+
+    if(debug == 2) println(hlog, T::print(p1), " ... ", T::print(p2), " = ", T::print(pd), " d=", d, " [i=", i, " dif=", dif, "]");
+
+    if(closeto(d, gd)) continue;
+
+    return i;
+    }
+  return 999;
+  }
+
+template<class T> double test_similarity(int id) { return test_distances<T>(id, 0); }
+template<class T> double test_dissimilarity(int id) { return test_distances<T>(id, 180); }
+template<class T> double test_other(int id) { return test_distances<T>(id, 1); }
+
+template<class T> double test_walk(int id) {
+  std::mt19937 testr; testr.seed(id);
+
+  ld step = 1/16.;
+  // mover-relative to cell-relative
+  auto R0 = random_rotation<T>(testr);
+  cell *c0 = hr::cwt.at;
+  auto R1 = T::apply(R0, cpush<T>(0, step/2));
+  cell *c1 = hr::cwt.at;
+
+  int i = 0;
+  int lastchange = 0;
+  while(i< lastchange + 1000 && i < 10000 && celldistance(c0, c1) < 3) {
+    // println(hlog, "iteration ", i, " in ", c0, " vs ", c1);
+    auto rebase = [&] (typename T::isometry& R, cell*& c, int id) {
+      ld d = T::dist0(T::apply(R, T::center()));
+      for(int dir=0; dir<c->type; dir++) {
+        cell *altc = c->cmove(dir);
+        auto altR = apply_move<T>(altc, c, R);
+        ld altd = T::dist0(T::apply(altR, T::center()));
+        if(altd < d + 1/256.) {
+          R = altR; c = altc; lastchange = i; return;
+          }
+        }
+      };
+    R0 = T::apply(R0, cpush<T>(0, step)); rebase(R0, c0, 0);
+    R1 = T::apply(R1, cpush<T>(0, step)); rebase(R1, c1, 1);
+    i++;
+    }
+
+  return i;
+  }
+
+template<class T> double test_close(int id) {
+  std::mt19937 testr; testr.seed(id);
+
+  cell *c = hr::cwt.at;
+  int phase = 0;
+  auto p0 = T::apply(cpush<T>(0, 1/8.), T::center());
+  auto p = p0;
+
+  int steps = 0;
+  const int maxdist = id + 1;
+  int errors = 0; 
+
+  while(steps < 10000) {
+    int d = testr() % c->type;
+    cell *c1 = c->cmove(d);
+
+    bool do_move = false;
+
+    switch(phase) {
+      case 0:
+        /* always move */
+        do_move = true;
+        if(celldistance(c1, hr::cwt.at) == maxdist) phase = 1;
+        break;
+
+      case 1:
+        /* move only towards the center */
+        int d0 = celldistance(c, hr::cwt.at);
+        int d1 = celldistance(c1, hr::cwt.at);
+        do_move = d1 < d0;
+        if(d1 == 0) phase = 0;
+        break;
+      }
+
+    if(do_move) {
+      p = apply_move<T>(c1, c, p); c = c1; steps++;
+      if(debug == 2) println(hlog, "dist = ", celldistance(c, hr::cwt.at), " dist = ", T::dist0(p));
+      if(c == hr::cwt.at) {
+        auto d = T::dist0(p);
+        auto a = T::angle(p);
+        if(!closeto(d, 1/8.) || !closeto_angle(a, 0)) {
+          errors++; phase = 0; c = hr::cwt.at; p = p0;
+          }
+        }
+      }
+    }
+
+  return errors;
+  }
+
+void run_all_tests() {
+  prepare_tests();
+
+  // println(hlog, "test_sanity"); TEST_ALL(test_sanity, data, 1, ld);
+
+  // println(hlog, "test_consistency"); TEST_ALL(test_consistency, data, 1, ld);
+
+  println(hlog, "test_loop_iso"); TEST_ALL(test_loop_iso, data, 20, int);
+
+  println(hlog, "test_loop_point"); TEST_ALL(test_loop_point, data, 20, int);
+
+  println(hlog, "test_angledist"); TEST_ALL(test_angledist, data, 3, int);
+
+  println(hlog, "test_similarity"); TEST_ALL(test_similarity, data, 20, int);
+
+  println(hlog, "test_dissimilarity"); TEST_ALL(test_dissimilarity, data, 20, int);
+
+  println(hlog, "test_other"); TEST_ALL(test_other, data, 20, int);
+
+  println(hlog, "test_walk"); TEST_ALL(test_walk, data, 20, int);
+
+  println(hlog, "test_close"); TEST_ALL(test_close, data, 20, int);
+
+  println(hlog, "test_count"); TEST_ALL(test_count, countdata, 1, std::string);
+  }
+
+}

devmods/rulegen-tests/tricky.lst

@@ -0,0 +1,241 @@
+tessellations/multitile/4-7/1+3a/1a2+3af/4-7-1a2+3af-30.tes
+tessellations/other/toimine/toimine884/112/toimine884-112-076.tes
+tessellations/other/toimine/toimine884/211/051-100/toimine884-211-072.tes
+tessellations/pseudo-Archimedean/Euclidean/4-uniform/eu\ 666\ 666\ 3366\ 333333\ AFAS6.tes
+tessellations/multitile/6-3/1+3a/6-3-1r2+3af-3.tes
+tessellations/other/heavpoot-a/hp-3a+6s3b+6a1.tes
+tessellations/multitile/3-6/1+3/3-6-1a+3a-3.tes
+tessellations/pseudo-Archimedean/Euclidean/4-uniform/eu 4444 33344 33344 33434 A1AFF.tes
+tessellations/pseudo-Archimedean/Euclidean/4-uniform/eu 33344 33434 333333 333333 FAS6S3b.tes
+tessellations/pseudo-Archimedean/Euclidean/4-uniform/eu 3cc 334c 33434 333333.tes
+tessellations/pseudo-Archimedean/Euclidean/4-uniform/eu 46c 3366 3446 33344.tes
+tessellations/multitile/4-6/2+2/2a1+2f/001-100/4-6-2a1+2f-083.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-58.tes
+tessellations/other/toimine/toimine6612/121/101-150/toimine6612-121-116.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-18.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-34.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-04.tes
+tessellations/multitile/3-7/1+2+3/3-7-1f+2r+3f-19.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-51.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/501-596/3-8-1f+2f+3f-545.tes
+tessellations/other/toimine/toimine6620/211/toimine6620-211-54.tes
+tessellations/other/toimine/toimine886/111/toimine886-111-08.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/501-596/3-8-1f+2f+3f-503.tes
+tessellations/other/toimine/toimine6610/121/toimine6610-121-20.tes
+tessellations/other/toimine/toimine6612/211/101-150/toimine6612-211-126.tes
+tessellations/polyschwartz/245/2-2 + 6-39.tes
+tessellations/other/toimine/toimine6615/121/toimine6615-121-02.tes
+tessellations/other/toimine/toimine6612/211/101-150/toimine6612-211-131.tes
+tessellations/multitile/polyforms/schwarz/245/1-1 + 4-8 s1.tes
+tessellations/other/toimine/toimine6617/113/toimine6617-113-16.tes
+tessellations/multitile/polyforms/schwarz/245/2-2 + 6-39.tes
+tessellations/other/toimine/toimine6618/211/151-159/toimine6618-211-151.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-16.tes
+tessellations/polyschwartz/237/1-1 + 7-08.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-59.tes
+tessellations/other/toimine/toimine6618/211/101-150/toimine6618-211-146.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/501-596/3-8-1f+2f+3f-568.tes
+tessellations/other/toimine/toimine6618/111/toimine6618-111-17.tes
+tessellations/other/toimine/toimine6612/211/201-243/toimine6612-211-243.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-52.tes
+tessellations/other/toimine/toimine885/211/toimine885-211-23.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-64.tes
+tessellations/other/toimine/toimine885/211/toimine885-211-44.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-58.tes
+tessellations/other/toimine/toimine6612/112/151-200/toimine6612-112-188.tes
+tessellations/multitile/polyforms/schwarz/245/45 + 410/12/45 + 410 + 410 s02.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-49.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/501-596/3-8-1f+2f+3f-564.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-42.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-03.tes
+tessellations/other/toimine/toimine6610/211/toimine6610-211-13.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-36.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-22.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-57.tes
+tessellations/other/toimine/toimine6618/112/toimine6618-112-002.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-60.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-06.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-53.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-02.tes
+tessellations/multitile/3-8/1+2+3/1f+2a1+3f/3-8-1f+2a1+3f-44.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-57.tes
+tessellations/other/toimine/toimine885/112/toimine885-112-10.tes
+tessellations/other/toimine/toimine6618/211/151-159/toimine6618-211-159.tes
+tessellations/other/toimine/toimine6618/211/101-150/toimine6618-211-117.tes
+tessellations/other/toimine/toimine6611/112/toimine6611-112-09.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-33.tes
+tessellations/other/toimine/toimine6618/211/051-100/toimine6618-211-070.tes
+tessellations/other/toimine/toimine6610/112/toimine6610-112-28.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-25.tes
+tessellations/other/toimine/toimine6610/211/toimine6610-211-27.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/401-500/3-8-1f+2f+3f-425.tes
+tessellations/other/toimine/toimine6617/113/toimine6617-113-13.tes
+tessellations/other/toimine/toimine6612/112/051-100/toimine6612-112-082.tes
+tessellations/other/toimine/toimine6620/111/toimine6620-111-09.tes
+tessellations/other/toimine/toimine668/121/toimine668-121-12.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-40.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/401-500/3-8-1f+2f+3f-496.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/101-200/3-8-1f+2f+3f-101.tes
+tessellations/other/toimine/toimine6612/112/151-200/toimine6612-112-164.tes
+tessellations/other/toimine/toimine6612/211/051-100/toimine6612-211-080.tes
+tessellations/other/toimine/toimine6611/121/toimine6611-121-11.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-11.tes
+tessellations/other/toimine/toimine6612/211/051-100/toimine6612-211-078.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-24.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-62.tes
+tessellations/other/toimine/toimine6612/121/001-050/toimine6612-121-012.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/401-500/3-8-1f+2f+3f-424.tes
+tessellations/other/toimine/toimine6617/113/toimine6617-113-12.tes
+tessellations/other/toimine/toimine6615/121/toimine6615-121-19.tes
+tessellations/other/toimine/toimine6612/121/201-227/toimine6612-121-226.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-12.tes
+tessellations/other/toimine/toimine6620/211/toimine6620-211-19.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/501-596/3-8-1f+2f+3f-563.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-03.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-31.tes
+tessellations/other/toimine/toimine6615/211/toimine6615-211-53.tes
+tessellations/other/toimine/toimine2311/4+2/toimine2311-4+2-07.tes
+tessellations/other/toimine/toimine6618/211/101-150/toimine6618-211-150.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-04.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-64.tes
+tessellations/multitile/polyforms/schwarz/245/1-1 + 4-8 s2.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-54.tes
+tessellations/multitile/polyforms/schwarz/237/1-1 + 7-08.tes
+tessellations/other/toimine/toimine6620/121/toimine6620-121-29.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-09.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-45.tes
+tessellations/other/toimine/toimine6612/211/101-150/toimine6612-211-122.tes
+tessellations/other/toimine/toimine6612/121/151-200/toimine6612-121-172.tes
+tessellations/other/toimine/toimine6612/121/201-227/toimine6612-121-211.tes
+tessellations/other/toimine/toimine6615/211/toimine6615-211-61.tes
+tessellations/other/toimine/toimine6612/112/151-200/toimine6612-112-155.tes
+tessellations/other/toimine/toimine6618/211/051-100/toimine6618-211-088.tes
+tessellations/other/toimine/toimine6612/211/051-100/toimine6612-211-086.tes
+tessellations/other/toimine/toimine6618/111/toimine6618-111-14.tes
+tessellations/polyschwartz/245/1-1 + 4-8 s2.tes
+tessellations/other/toimine/toimine6612/112/101-150/toimine6612-112-142.tes
+tessellations/other/toimine/toimine6612/211/001-050/toimine6612-211-045.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-36.tes
+tessellations/multitile/4-6/2+2/2a1+2f/001-100/4-6-2a1+2f-033.tes
+tessellations/other/toimine/toimine6612/121/151-200/toimine6612-121-177.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-20.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/401-500/3-8-1f+2f+3f-445.tes
+tessellations/other/toimine/toimine6618/121/051-100/toimine6618-121-066.tes
+tessellations/other/toimine/toimine6612/111/toimine6612-111-30.tes
+tessellations/multitile/4-6/2+2/2f+2f/401-500/4-6-2f+2f-466.tes
+tessellations/other/toimine/toimine6617/113/toimine6617-113-14.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-12.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-09.tes
+tessellations/other/toimine/toimine6610/211/toimine6610-211-17.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-69.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-17.tes
+tessellations/other/toimine/toimine6611/121/toimine6611-121-04.tes
+tessellations/other/toimine/toimine6610/211/toimine6610-211-23.tes
+tessellations/other/toimine/toimine668/211/toimine668-211-08.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-40.tes
+tessellations/other/toimine/toimine6612/211/201-243/toimine6612-211-233.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-35.tes
+tessellations/other/toimine/toimine6618/211/051-100/toimine6618-211-058.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/301-400/3-8-1f+2f+3f-396.tes
+tessellations/other/toimine/toimine6612/112/101-150/toimine6612-112-124.tes
+tessellations/other/toimine/toimine668/112/toimine668-112-04.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-53.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-50.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-47.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-05.tes
+tessellations/other/toimine/toimine668/112/toimine668-112-02.tes
+tessellations/other/toimine/toimine6612/112/101-150/toimine6612-112-136.tes
+tessellations/polyschwartz/245/1-1 + 5-01.tes
+tessellations/other/toimine/toimine6612/112/201-250/toimine6612-112-219.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-18.tes
+tessellations/multitile/polyforms/schwarz/245/1-1 + 5-01.tes
+tessellations/other/toimine/toimine6618/121/101-126/toimine6618-121-114.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-51.tes
+tessellations/other/toimine/toimine6618/211/051-100/toimine6618-211-060.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-21.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-37.tes
+tessellations/other/toimine/toimine6612/211/201-243/toimine6612-211-232.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-08.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-15.tes
+tessellations/other/toimine/toimine6620/211/toimine6620-211-36.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-45.tes
+tessellations/other/toimine/toimine6618/211/101-150/toimine6618-211-129.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-70.tes
+tessellations/other/toimine/toimine6610/121/toimine6610-121-16.tes
+tessellations/polyschwartz/245/45 + 410/12/45 + 410 + 410 s02.tes
+tessellations/multitile/polyforms/schwarz/245/1-1 + 4-8 s3.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-76.tes
+tessellations/other/toimine/toimine6620/112/toimine6620-112-47.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-14.tes
+tessellations/multitile/3-7/1+1+3/3-7-1f+1f+3f-20.tes
+tessellations/other/toimine/toimine6618/211/051-100/toimine6618-211-065.tes
+tessellations/other/toimine/toimine6610/112/toimine6610-112-06.tes
+tessellations/other/toimine/toimine885/121/toimine885-121-34.tes
+tessellations/other/toimine/toimine6615/211/toimine6615-211-04.tes
+tessellations/other/toimine/toimine6618/121/051-100/toimine6618-121-086.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/101-200/3-8-1f+2f+3f-169.tes
+tessellations/other/toimine/toimine885/211/toimine885-211-37.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-55.tes
+tessellations/other/toimine/toimine2311/4+2/toimine2311-4+2-60.tes
+tessellations/multitile/4-6/2+2/2f+2f/401-500/4-6-2f+2f-447.tes
+tessellations/other/toimine/toimine6612/211/051-100/toimine6612-211-059.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-61.tes
+tessellations/other/toimine/toimine6620/111/toimine6620-111-07.tes
+tessellations/other/toimine/toimine6618/121/051-100/toimine6618-121-056.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-48.tes
+tessellations/other/toimine/toimine6612/211/101-150/toimine6612-211-125.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-47.tes
+tessellations/polyschwartz/245/1-1 + 4-8 s3.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-13.tes
+tessellations/other/toimine/toimine885/121/toimine885-121-25.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-59.tes
+tessellations/other/toimine/toimine6615/211/toimine6615-211-44.tes
+tessellations/other/toimine/toimine6612/111/toimine6612-111-26.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-26.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/501-596/3-8-1f+2f+3f-596.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-49.tes
+tessellations/other/toimine/toimine2311/4+2/toimine2311-4+2-42.tes
+tessellations/other/toimine/toimine6618/211/151-159/toimine6618-211-156.tes
+tessellations/other/toimine/toimine6618/121/051-100/toimine6618-121-096.tes
+tessellations/other/toimine/toimine6618/121/101-126/toimine6618-121-125.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-11.tes
+tessellations/other/toimine/toimine2311/3+3/toimine2311-3+3-46.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-34.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-54.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-56.tes
+tessellations/other/toimine/toimine6618/211/101-150/toimine6618-211-128.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/001-100/3-8-1f+2f+3f-091.tes
+tessellations/other/toimine/toimine668/211/toimine668-211-17.tes
+tessellations/other/toimine/toimine6612/112/151-200/toimine6612-112-153.tes
+tessellations/other/toimine/toimine6612/112/201-250/toimine6612-112-215.tes
+tessellations/other/toimine/toimine668/112/toimine668-112-28.tes
+tessellations/other/toimine/toimine668/112/toimine668-112-01.tes
+tessellations/other/toimine/toimine6620/121/toimine6620-121-37.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-63.tes
+tessellations/other/toimine/toimine6610/211/toimine6610-211-19.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-29.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-43.tes
+tessellations/other/toimine/toimine6618/121/101-126/toimine6618-121-126.tes
+tessellations/other/toimine/toimine668/211/toimine668-211-19.tes
+tessellations/other/toimine/toimine6612/112/101-150/toimine6612-112-140.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-30.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-32.tes
+tessellations/multitile/3-11/1+1+1/3-11-1a+1a+1f-2.tes
+tessellations/polyschwartz/245/1-1 + 4-8 s1.tes
+tessellations/other/toimine/toimine6618/211/101-150/toimine6618-211-110.tes
+tessellations/other/toimine/toimine6612/112/151-200/toimine6612-112-176.tes
+tessellations/other/toimine/toimine6618/211/101-150/toimine6618-211-149.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-50.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-62.tes
+tessellations/other/toimine/toimine886/211/toimine886-211-011.tes
+tessellations/other/toimine/toimine6615/111/toimine6615-111-28.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-44.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-10.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-38.tes
+tessellations/other/toimine/toimine2311/2+4/toimine2311-2+4-46.tes
+tessellations/other/toimine/toimine6618/211/101-150/toimine6618-211-125.tes
+tessellations/other/toimine/toimine6620/211/toimine6620-211-18.tes
+tessellations/other/toimine/toimine668/211/toimine668-211-21.tes
+tessellations/other/toimine/toimine6610/121/toimine6610-121-04.tes
+tessellations/other/toimine/toimine6611/112/toimine6611-112-02.tes
+tessellations/multitile/3-8/1+2+3/1f+2f+3f/501-596/3-8-1f+2f+3f-565.tes

devmods/rulegen.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+# compact honeycombs
+
+./mymake -O3 devmods/honeycomb-rule-generator
+
+./hyper -geo 534h -gen-rule honeycomb-rules-534.dat -quit
+./hyper -geo 535h -gen-rule honeycomb-rules-535.dat -quit
+./hyper -geo 435h -gen-rule honeycomb-rules-435.dat -quit
+./hyper -geo 353h -gen-rule honeycomb-rules-353.dat -quit
+
+# exh 2 optimized
+./hyper -geo 436h -exh 2 -gen-rule honeycomb-rules-436.dat -quit
+./hyper -geo 344h -exh 2 -gen-rule honeycomb-rules-344.dat -quit
+./hyper -geo 354h -exh 2 -gen-rule honeycomb-rules-354.dat -quit
+./hyper -geo 536h -exh 2 -gen-rule honeycomb-rules-536.dat -quit
+
+# still generates conflicts on exh 2:
+# ./hyper -geo 355h -exh 2 -gen-rule honeycomb-rules-355.dat -quit #
+# ./hyper -geo 345h -exh 2 -gen-rule honeycomb-rules-345.dat -quit #

devmods/solv-error-analyze.cpp

@@ -0,0 +1,593 @@
+#include "../hyper.h"
+
+// This program generates the error table for Solv approxiations.
+
+#define D3 1
+#define D2 0
+
+#if CAP_FIELD
+namespace hr {
+
+ld solerror(hyperpoint ok, hyperpoint chk) {
+  return geo_dist(chk, ok);
+  }
+
+ld minz = -1e-9, maxz = 1e-9;
+
+int max_iter = 999999;
+
+bool isok;
+
+hyperpoint iterative_solve(hyperpoint xp, hyperpoint candidate, ld minerr, bool debug = false) {
+
+  transmatrix T = Id; T[0][1] = 8; T[2][2] = 5;
+  
+  auto f = [&] (hyperpoint x) { return nisot::numerical_exp(x); }; // T * x; };
+
+  auto ver = f(candidate);
+  ld err = solerror(xp, ver);
+  auto at = candidate;
+  
+  ld eps = 1e-6;
+
+  hyperpoint c[6];
+  for(int a=0; a<3; a++) c[a] = point3(a==0, a==1, a==2);
+  for(int a=0; a<3; a++) c[3+a] = point3(-(a==0), -(a==1), -(a==2));
+  
+  int iter = 0;
+  
+  while(err > minerr) { again:
+    iter++; if(iter > max_iter) { isok = false; return at; }
+    // cands.push_back(at);
+    if(debug) println(hlog, "\n\nf(", at, "?) = ", ver, " (error ", err, ")");
+    array<hyperpoint, 3> pnear;
+    
+    for(int a=0; a<3; a++) {
+      auto x = at + c[a] * eps;
+      if(debug) println(hlog, "f(", x, ") = ", f(x), " = y + ", f(x)-ver, "imp ", err - solerror(xp, f(x)) );
+      auto y = at - c[a] * eps;
+      if(debug) println(hlog, "f(", y, ") = ", f(y), " = y + ", f(y)-ver, "imp ", err - solerror(xp, f(y)) );
+      pnear[a] = (f(x) - ver) / eps; //  (direct_exp(at + c[a] * eps, prec) - ver) / eps;
+      }
+    
+    transmatrix U = Id;
+    for(int a=0; a<3; a++) 
+    for(int b=0; b<3; b++)
+      U[a][b] = pnear[b][a];
+
+    hyperpoint diff = (xp - ver);
+    
+    hyperpoint bonus = inverse(U) * diff;
+    
+    ld lbonus = hypot_d(3, bonus);
+    
+    if(lbonus > 0.1) bonus = bonus * 0.1 / hypot_d(3, bonus);
+    
+    if(false && lbonus > 1000) {
+      int best = -1;
+      ld besti = err;
+      for(int a=0; a<6; a++) {
+        auto x = at + c[a] * eps;
+        auto nerr = solerror(xp, f(x));
+        if(nerr < besti) best = a, besti = nerr;
+        }
+      if(best == -1) { 
+        println(hlog, "local best"); 
+        for(int a=0; a<1000000; a++) {
+          auto x = at;
+          for(int i=0; i<3; i++) x[i] += (hrand(1000000) - hrand(1000000)) * 1e-5;
+          auto nerr = solerror(xp, f(x));
+          if(nerr < besti) { println(hlog, "moved to ", x); at = x; goto again; }
+          }
+        break; 
+        }
+      bonus = c[best] * 1e-3;
+      }
+    
+    int fixes = 0;
+    
+    if(debug) 
+      println(hlog, "\nU = ", U, "\ndiff = ", diff, "\nbonus = ", bonus, " of ", lbonus, "\n");
+    
+    nextfix:
+    hyperpoint next = at + bonus;
+    hyperpoint nextver = f(next);
+    ld nexterr = solerror(xp, nextver);
+    if(debug) println(hlog, "f(", next, ") = ", nextver, ", imp = ", err - nexterr);
+    
+    if(nexterr < err) {
+      // println(hlog, "reduced error ", err, " to ", nexterr);
+      at = next;
+      ver = nextver;
+      err = nexterr;
+      continue;
+      }
+    else {
+      bonus /= 2;
+      fixes++;
+      if(fixes > 10) {
+        if(err > 999) {
+          for(ld s = 1; abs(s) > 1e-9; s *= 0.5)
+          for(int k=0; k<27; k++) {
+            int kk = k;
+            next = at;
+            for(int i=0; i<3; i++) { if(kk%3 == 1) next[i] += s; if(kk%3 == 2) next[i] -= s; kk /= 3; }
+            // next = at + c[k] * s;
+            nextver = f(next);
+            nexterr = solerror(xp, nextver);
+            // println(hlog, "f(", next, ") = ", nextver, ", error = ", nexterr);
+            if(nexterr < err) { at = next; ver = nextver; err = nexterr; goto nextiter; }
+            }
+            println(hlog, "cannot improve error ", err);
+            exit(1);
+          }
+        if(debug) println(hlog, "fixes = ", fixes, " : break");
+        isok = false;
+        return at;
+        }
+      goto nextfix;
+      }
+    
+    nextiter: ;
+    }
+
+  if(debug) println(hlog, "\n\nsolution found: f(", at, ") = ", ver, " (error ", err, ")");
+  
+  isok = true;
+  
+  return at;
+  }
+
+EX void geodesic_step_euler(hyperpoint& at, hyperpoint& velocity) {
+  auto acc = nisot::christoffel(at, velocity, velocity);
+  at = at + velocity + acc / 2;
+  velocity += acc;
+  }
+
+EX void geodesic_step_poor(hyperpoint& at, hyperpoint& velocity) {
+  auto acc = nisot::christoffel(at, velocity, velocity);
+  at = at + velocity;
+  velocity += acc;
+  }
+
+EX void geodesic_step_midpoint(hyperpoint& at, hyperpoint& velocity) {
+
+  // y(n+1) = y(n) + f(y(n) + 1/2 f(y(n)))
+  
+  auto acc = nisot::christoffel(at, velocity, velocity);
+  auto at2 = at + velocity / 2;
+  auto velocity2 = velocity + acc / 2;
+      
+  auto acc2 = nisot::christoffel(at2, velocity2, velocity2);
+  
+  at = at + velocity + acc2 / 2;
+  
+  velocity = velocity + acc2;
+  }
+
+auto& chr = nisot::get_acceleration;
+
+EX bool invalid_any(const hyperpoint h) {
+  return isnan(h[0]) || isnan(h[1]) || isnan(h[2]) || isinf(h[0]) || isinf(h[1]) || isinf(h[2]) ||
+    abs(h[0]) > 1e20 || abs(h[1]) > 1e20 || abs(h[2]) > 1e20;
+  }
+
+EX void geodesic_step_rk4(hyperpoint& at, hyperpoint& vel) {
+  auto acc1 = chr(at, vel);
+  auto acc2 = chr(at + vel/2, vel + acc1/2);
+  auto acc3 = chr(at + vel/2 + acc1/4, vel + acc2/2);
+  auto acc4 = chr(at + vel + acc2/2, vel + acc3);
+  
+  at += vel + (acc1+acc2+acc3)/6;
+  vel += (acc1+2*acc2+2*acc3+acc4)/6;
+  }
+
+template<class T> 
+hyperpoint numerical_exp(hyperpoint v, int steps, const T& gstep) {
+  hyperpoint at = point31(0, 0, 0);
+  v /= steps;
+  v[3] = 0;
+  for(int i=0; i<steps; i++) {
+    if(invalid_any(at)) return at;
+    gstep(at, v);
+    }    
+  return at;
+  }
+
+ld x_to_scr(ld x) { return 150 + 100 * x; }
+ld y_to_scr(ld x) { return 950 - log(x * 1e9) / log(10) * 80; }
+
+hyperpoint pt(ld x, ld y) { return tC0(atscreenpos(x, y, 1)); };
+
+map<pair<string, color_t>, map<double, double>> maxerr;
+
+bool scatterplot;
+
+void queueline1(hyperpoint a, hyperpoint b, color_t c) {
+  queueline(shiftless(a), shiftless(b), c);
+  }
+
+void draw_graph() {
+  vid.linewidth *= 2;
+  queueline1(pt(0, 950), pt(1500, 950), 0xFF);
+  queueline1(pt(150, 0), pt(150, 1000), 0xFF);
+  
+  vid.linewidth /= 2;
+  
+  for(int i=1; i<=9; i++) {
+    queueline1(pt(x_to_scr(i), 950), pt(x_to_scr(i), 960), 0xFF);
+    queuestr(x_to_scr(i), 980, 0, 60, its(i), 0, 0, 8);
+    }
+  
+  for(int i=-8; i<=2; i++) {
+    ld v = pow(10, i);
+    queueline1(pt(140, y_to_scr(v)), pt(150, y_to_scr(v)), 0xFF);
+    queuestr(70, y_to_scr(v), 0, 60, "1e"+its(i), 0, 0, 8);
+    vid.linewidth /= 2;
+    queueline1(pt(1100, y_to_scr(v)), pt(150, y_to_scr(v)), 0xFF);
+    vid.linewidth *= 2;
+    }
+  
+  vid.linewidth *= 2;
+  for(auto& [id, graph]: maxerr) {
+    auto& [name, col] = id;
+    ld last = 1e-9;
+    ld lastx = 0;
+    for(auto [x, y]: graph) {
+      if(scatterplot) {
+        curvepoint(pt(x_to_scr(x)+2, y_to_scr(y)));
+        curvepoint(pt(x_to_scr(x)-2, y_to_scr(y)));
+        queuecurve(shiftless(Id), col, 0, PPR::LINE);
+        curvepoint(pt(x_to_scr(x), y_to_scr(y)+2));
+        curvepoint(pt(x_to_scr(x), y_to_scr(y)-2));
+        queuecurve(shiftless(Id), col, 0, PPR::LINE);
+        }
+      if(y_to_scr(y) > y_to_scr(last) - x_to_scr(lastx) + x_to_scr(x)) continue;
+      if(y > 100) y = 100;
+      last = y;
+      lastx = x;
+      ld xx = x;
+      if(xx > 9) xx = 9;
+      if(!scatterplot) curvepoint(pt(x_to_scr(x), y_to_scr(y)));
+      if(xx == 9) break;
+      }
+    if(!scatterplot) {
+      queuestr(1100, y_to_scr(last), 0, 60, name, col >> 8, 0, 0);
+      queuecurve(shiftless(Id), col, 0, PPR::LINE);
+      }
+    }
+  vid.linewidth /= 2;
+  
+  drawqueue();
+  }
+  
+void draw_sol_diffeq_graph() {
+  }
+
+void make_graph(string fname) {
+
+  start_game();
+  
+  flat_model_enabler fme;
+
+  shot::shotx = 1500;
+  shot::shoty = 1000;
+  shot::format = shot::screenshot_format::svg;
+  svg::divby = 1;
+
+  shot::take(fname, draw_graph);
+  }  
+
+void sol_diffeq_graph() {
+
+  auto& s = sn::get_tabled();
+  s.load();
+
+  for(int x=0; x<s.PRECX-1; x++)
+  for(int y=0; y<s.PRECY-1; y++)
+  for(int z=0; z<s.PRECZ-1; z++) {
+    println(hlog, tie(x,y,z));
+    auto ax = sn::ix_to_x(x / (s.PRECX-1.));
+    auto ay = sn::ix_to_x(y / (s.PRECY-1.));
+    auto az = sn::iz_to_z(z / (s.PRECZ-1.));
+    
+    ld d = hypot(ax, hypot(ay, az));
+    
+    hyperpoint h = point31(ax, ay, az);
+    hyperpoint v = inverse_exp(shiftless(h)); // , pfNO_INTERPOLATION);
+    
+    hyperpoint actual = numerical_exp(v, 2000, geodesic_step_rk4);
+    if(invalid_any(actual)) continue;
+    
+    auto test = [&] (string name, color_t col, int iter, auto method) {
+      hyperpoint res = numerical_exp(v, iter, method);
+      if(invalid_any(res)) return;
+      ld err = geo_dist(actual, res);
+      ld& me = maxerr[{name, col}][d];
+      me = max(me, err);
+      };
+    
+    test("RK2 5", 0xB0E0B0FF, 5, geodesic_step_rk4);
+    test("RK2 10", 0x8AD0A0FF, 10, geodesic_step_rk4);
+    test(" ", 0x90E090FF, 20, geodesic_step_rk4);
+    test("RK2 30", 0x80C080FF, 30, geodesic_step_rk4);
+    test("RK4 100", 0x408040FF, 100, geodesic_step_rk4);
+    test("RK4 300", 0x306030FF, 300, geodesic_step_rk4);
+    test("RK4 1000", 0x204020FF, 1000, geodesic_step_rk4);
+    test("mid 100", 0x8080C0FF, 100, geodesic_step_midpoint);
+    test("mid 1000", 0x404080FF, 1000, geodesic_step_midpoint);
+    }
+  
+  make_graph("sol-diff-graph.svg");
+  }
+
+void sol_numerics_out() {
+  hyperpoint v = inverse_exp(shiftless(point31(2, 1, 0)));
+  // point3(0.1, 0, 10);
+  
+  hyperpoint result = numerical_exp(v, 1000000, geodesic_step_rk4);
+  
+  println(hlog, "exp(", v, ") = ", result);
+
+  for(int steps: {1, 2, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000, 100000}) {
+    shstream ss;
+    auto experiment = [&] (string name, auto f) {
+      print(ss, name, lalign(30, hdist0(numerical_exp(v, steps, f) - result)));
+      };
+    experiment(" P ", geodesic_step_poor);
+    experiment(" E ", geodesic_step_euler);
+    experiment(" M ", geodesic_step_midpoint);
+    experiment(" R ", geodesic_step_rk4);
+    println(hlog, " steps=", lalign(6, steps), ss.s);
+    }
+  
+  println(hlog, "timing M");
+  numerical_exp(v, 10000000, geodesic_step_midpoint);
+
+  println(hlog, "timing R");
+  numerical_exp(v, 10000000, geodesic_step_rk4);
+  
+  println(hlog, "ok");
+  }
+
+vector<ld> quantiles(vector<ld> data) {
+  sort(data.begin(), data.end());
+  if(isize(data) <= 20) return data;
+  vector<ld> q;
+  for(int i=0; i<=20; i++)
+    q.push_back(data[(isize(data)-1)*i/20]);
+  return q;
+  }
+
+auto smax(auto& tab, ld& i, ld x) { if(x) tab[i] = max(tab[i], x); }
+
+ld median(vector<ld> v) {
+  sort(v.begin(), v.end());
+  return v[isize(v)/2];
+  }
+  
+void sol_table_test() {
+
+  // auto& length_good = maxerr[{"length/good", 0x408040FF}];
+  // auto& angle_good = maxerr[{"angle/good", 0x404080FF}];
+
+  // auto& length_good2 = maxerr[{"length/mid", 0x808040FF}];
+  // auto& angle_good2 = maxerr[{"angle/mid", 0x804080FF}];
+
+  // auto& length_bad = maxerr[{"length/bad", 0xC08040FF}];
+  // auto& angle_bad = maxerr[{"angle/bad", 0xC04080FF}];
+  
+  // map<string, int> wins;
+
+  auto& s = sn::get_tabled();
+  s.load();
+  
+  map<double, double> maxerr;
+  
+  int good = 0, bad = 0;
+  
+  vector<ld> length_errors;
+  vector<ld> angle_errors;
+  
+  vector<ld> split;
+  
+  vector<ld> lerrs[4][4][4], aerrs[4][4][4];
+  
+  for(int a: {16, 32, 48, 60})
+    println(hlog, "xy_", a, " : ", sn::ix_to_x(a / (s.PRECX-1.)));
+
+  for(int a: {16, 32, 48, 60})
+    println(hlog, "z_", a, " : ", sn::iz_to_z(a / (s.PRECZ-1.)));
+    
+  
+  FILE *g = fopen("solv-error-data.csv", "wt");
+  
+  for(ld x=0; x<s.PRECX-4; x+=.25)
+  for(ld y=0; y<s.PRECY-4; y+=.25)
+  for(ld z=0; z<s.PRECZ-4; z+=.25) {
+  
+    int xp = x * 4 / s.PRECX;
+    int yp = y * 4 / s.PRECY;
+    int zp = z * 4 / s.PRECZ;
+  
+    if(y == 0.5 && z== 0.5) println(hlog, x, " : ", good, " vs ", bad);
+  
+    int a0 = 0, b0 = 0;
+    
+    for(ld x1: {floor(x), ceil(x)})
+    for(ld y1: {floor(y), ceil(y)})
+    for(ld z1: {floor(z), ceil(z)}) {
+      auto ax = sn::ix_to_x(x1 / (s.PRECX-1.));
+      auto ay = sn::ix_to_x(y1 / (s.PRECY-1.));
+      auto az = sn::iz_to_z(z1 / (s.PRECZ-1.));
+  
+      hyperpoint h = point31(ax, ay, az);
+  
+      hyperpoint v = inverse_exp(shiftless(h), pfNO_INTERPOLATION);
+      
+      if(v[2] > 0) a0++;
+      else b0++;
+      }
+    
+    bool bad_region = x > s.PRECX/2 && y > s.PRECY/2 && z < s.PRECZ/2;
+    
+    bool bad_break = bad_region && a0 && b0;
+    
+    auto ax = sn::ix_to_x(x / (s.PRECX-1.));
+    auto ay = sn::ix_to_x(y / (s.PRECY-1.));
+    auto az = sn::iz_to_z(z / (s.PRECZ-1.));
+
+    hyperpoint h = point31(ax, ay, az);
+
+    hyperpoint v = inverse_exp(shiftless(h), bad_break ? pfNO_INTERPOLATION : pNORMAL);
+    
+    // println(hlog, "looking for ", h);
+    
+    // println(hlog, "exp(", v, ") = ", nisot::numerical_exp(v));
+    
+    hyperpoint v1 = iterative_solve(h, v, 1e-9, false);
+
+    // println(hlog, "exp(", v1, ") = ", nisot::numerical_exp(v1));
+    
+    hyperpoint h2 = nisot::numerical_exp(v1);
+    
+    if(sqhypot_d(3, h-h2) > 1e-6) {
+      bad++; 
+      continue;
+      }
+    else good++;
+    
+    ld dv  = hypot_d(3, v);
+    ld dv1 = hypot_d(3, v1);
+    
+    ld lerr = abs(dv - dv1);
+    ld aerr = asin(hypot_d(3, v^v1) / dv / dv1);
+    
+    ld d    = hypot_d(3, v1);
+    
+    if(dv == 0 || dv1 == 0) continue;
+    
+    if(invalid_any(v1) || invalid_any(v)) {
+      println(hlog, "invalid");
+      continue;
+      }
+    
+    if(isnan(aerr)) println(hlog, "v = ", v, " v1 = ", v1, "aerr");
+    
+    else fprintf(g, "%lf;%lf;%lf;%lf;%lf;%lf;%lf;%lf;%d\n",
+      x, y, z, 
+      ax, ay, az, 
+      lerr, aerr,
+      bad_break
+      );
+    
+    lerrs[zp][yp][xp].push_back(lerr);
+    aerrs[zp][yp][xp].push_back(aerr);
+    }
+  
+  fclose(g);
+
+    
+/*
+    if(d >= 3 && d <= 3.1 && !bad_region) {
+      println(hlog, tie(x,y,z), " : ", lerr);
+      split.push_back(lerr);
+      }
+    
+    if(bad_break) 
+      smax(length_bad, d, lerr), 
+      smax(angle_bad, d, aerr),
+      0;
+    else if(bad_region) 
+      smax(length_good2, d, lerr), 
+      smax(angle_good2, d, aerr),
+      0;
+    else
+      smax(length_good, d, lerr),
+      smax(angle_good, d, aerr),
+      0;
+    length_errors.push_back(lerr);
+    
+    ld cross = hypot_d(3, v^v1) / dv / dv1;
+    
+    angle_errors.push_back(cross);
+    } 
+  
+  // println(hlog, quantiles(length_errors));
+  println(hlog, quantiles(split)); */
+  
+  // for(auto p: angle_good) println(hlog, p);
+  
+  // make_graph("sol-la-errors.svg");
+  
+  FILE *f = fopen("devmods/graph.tex", "wt");
+
+
+  fprintf(f, "\\documentclass{article}\n\\begin{document}\n");
+  fprintf(f, "\\small\\setlength{\\tabcolsep}{3pt}\n");
+
+  fprintf(f, "\\begin{tabular}{|c|cccc|cccc|cccc|cccc|}\n\\hline\n");
+  for(int z=0; z<4; z++) {
+    fprintf(f, " & ");
+    fprintf(f, "\\multicolumn{4}{|c%s}{$z_%d$}", z==3?"|":"", z);
+    }
+  fprintf(f, "|\\\\\n");
+  for(int z=0; z<4; z++) {
+    for(int x=0; x<4; x++) {
+      fprintf(f, " & ");
+      fprintf(f, "$x_%d$", x);
+      }
+    }
+  fprintf(f, "\\\\\n\\hline");
+  for(int y=0; y<4; y++) {
+    fprintf(f, "$y_%d$ ", y);
+    for(int z=0; z<4; z++) {
+      for(int x=0; x<4; x++) {
+        fprintf(f, " & ");
+        fprintf(f, "%4.2g", log10(median(lerrs[z][y][x])));
+        }
+      }
+    fprintf(f, "\\\\\n");
+    }
+  fprintf(f, "\\hline \n");
+  for(int y=0; y<4; y++) {
+    fprintf(f, "$y_%d$ ", y);
+    for(int z=0; z<4; z++) {
+      for(int x=0; x<4; x++) {
+        fprintf(f, " & ");
+        fprintf(f, "%4.2g", log10(median(aerrs[z][y][x])));
+        }
+      }
+    fprintf(f, "\\\\\n");
+    }
+  fprintf(f, "\\hline\n");
+  fprintf(f, "\\end{tabular}\n");
+  fprintf(f, "\\end{document}\n");
+  fclose(f);
+  }
+
+int readArgs() {
+  using namespace arg;
+           
+  if(0) ;
+
+  else if(argis("-sol-diff-graph")) {
+    sol_diffeq_graph();
+    }
+
+  else if(argis("-sol-tabletest")) {
+    sol_table_test();
+    }
+
+  else if(argis("-sol-numerics")) {
+    sol_numerics_out();
+    }
+
+  else return 1;
+  return 0;
+  }
+
+auto nhook = addHook(hooks_args, 100, readArgs);
+
+}
+#endif

devmods/solv-table.cpp

@@ -0,0 +1,585 @@
+// This generates the inverse geodesics tables.
+
+// Usage: 
+
+// [executable] -geo sol -build -write solv-geodesics.dat
+//              -geo 3:2 -build -write shyp-geodesics.dat
+//              -geo 3:1/2 -build -write ssol-geodesics.dat
+//              -exit
+
+// Loading generated tables and visualization: 
+// [executable] /hyper -fsol [filename] -geo sol -visualize filename-%03d.png
+
+// You can also do -geo [...] -build to build and test the table
+// without writing it.
+
+// By default this generates 64x64x64 tables.
+// Add e.g. '-dim 128 128 128' before -write to generate
+// a more/less precise table.
+
+// # ./hyper -rk-steps 100 -geo Sol -iz-list -sn-unittest -build -write solv-geodesics-a.dat -visualize devmods/san1/solva-%04d.png -improve -write solv-geodesics.dat -visualize devmods/san1/solvb-%04d.png
+// # ./hyper -dim 32 32 32 -geo 3:1/2 -iz-list -sn-unittest -build -write ssol-geodesics-a.dat -visualize devmods/san1/ssola-%04d.png -improve -write ssol-geodesics.dat -visualize devmods/san1/ssolb-%04d.png
+// # ./hyper -dim 32 32 32 -geo 3:2 -iz-list -sn-unittest -build -write shyp-geodesics.dat -visualize devmods/san1/shypa-%04d.png
+
+#include "../hyper.h"
+
+#include <thread>
+#include <mutex>
+
+namespace hr {
+
+transmatrix parabolic1(ld u);
+
+namespace sn {
+
+template<class T> void parallelize(int threads, int Nmin, int Nmax, T action) {
+  std::vector<std::thread> v;
+  for(int k=0; k<threads; k++)
+    v.emplace_back([&,k] () { 
+      for(int i=Nmin+k; i < Nmax; i += threads) action(k, i);
+      });
+  for(std::thread& t:v) t.join();
+  }
+
+ld solerror(hyperpoint ok, hyperpoint chk) {
+  auto zok  = point3( x_to_ix(ok[0]), x_to_ix(ok[1]), z_to_iz(ok[2]) );
+  auto zchk = point3( x_to_ix(chk[0]), x_to_ix(chk[1]), z_to_iz(chk[2]) );
+  return hypot_d(3, zok - zchk);
+  }
+
+int max_iter = 999999;
+
+hyperpoint fail(.1, .2, .3, .4);
+
+hyperpoint iterative_solve(hyperpoint xp, hyperpoint candidate, ld minerr, bool debug = false) {
+
+  transmatrix T = Id; T[0][1] = 8; T[2][2] = 5;
+  
+  auto f = [&] (hyperpoint x) { return nisot::numerical_exp(x); }; // T * x; };
+
+  auto ver = f(candidate);
+  ld err = solerror(xp, ver);
+  auto at = candidate;
+  
+  ld eps = 1e-6;
+
+  hyperpoint c[3];  
+  for(int a=0; a<3; a++) c[a] = point3(a==0, a==1, a==2);
+  
+  int iter = 0;
+  
+  while(err > minerr) {
+
+    iter++; if(iter > max_iter) return fail;
+
+    if(debug) println(hlog, "\n\nf(", at, "?) = ", ver, " (error ", err, ")");
+    array<hyperpoint, 3> pnear;
+    for(int a=0; a<3; a++) {
+      auto x = at + c[a] * eps;
+      if(debug) println(hlog, "f(", x, ") = ", f(x), " = y + ", f(x)-ver );
+      pnear[a] = (f(x) - ver) / eps; //  (direct_exp(at + c[a] * eps, prec) - ver) / eps;
+      }
+    
+    transmatrix U = Id;
+    for(int a=0; a<3; a++) 
+    for(int b=0; b<3; b++)
+      U[a][b] = pnear[b][a];
+
+    hyperpoint diff = (xp - ver);
+    
+    hyperpoint bonus = inverse(U) * diff;
+    
+    if(hypot_d(3, bonus) > 0.1) bonus = bonus * 0.1 / hypot_d(3, bonus);
+    
+    int fixes = 0;
+    
+    if(debug) 
+      println(hlog, "\nU = ", U, "\ndiff = ", diff, "\nbonus = ", bonus, "\n");
+    
+    nextfix:
+    hyperpoint next = at + bonus;
+    hyperpoint nextver = f(next);
+    ld nexterr = solerror(xp, nextver);
+    if(debug) println(hlog, "f(", next, ") = ", nextver, ", error = ", nexterr);
+    
+    if(nexterr < err) {
+      // println(hlog, "reduced error ", err, " to ", nexterr);
+      at = next;
+      ver = nextver;
+      err = nexterr;
+      continue;
+      }
+    else {
+      bonus /= 2;
+      fixes++;
+      if(fixes > 10) {
+        if(err > 999) {
+          for(ld s = 1; abs(s) > 1e-9; s *= 0.5)
+          for(int k=0; k<27; k++) {
+            int kk = k;
+            next = at;
+            for(int i=0; i<3; i++) { if(kk%3 == 1) next[i] += s; if(kk%3 == 2) next[i] -= s; kk /= 3; }
+            // next = at + c[k] * s;
+            nextver = f(next);
+            nexterr = solerror(xp, nextver);
+            // println(hlog, "f(", next, ") = ", nextver, ", error = ", nexterr);
+            if(nexterr < err) { at = next; ver = nextver; err = nexterr; goto nextiter; }
+            }
+            println(hlog, "cannot improve error ", err);
+            exit(1);
+          }
+        return fail;
+        }
+      goto nextfix;
+      }
+    
+    nextiter: ;
+    }
+  
+  // println(hlog, "#it = ", iter);
+  
+  return at;
+  }
+
+using ptlow = compressed_point;
+
+ptlow operator +(ptlow a, ptlow b) { return make_array<float>(a[0]+b[0], a[1]+b[1], a[2]+b[2]); }
+ptlow operator -(ptlow a, ptlow b) { return make_array<float>(a[0]-b[0], a[1]-b[1], a[2]-b[2]); }
+ptlow operator *(ptlow a, ld x) { return make_array<float>(a[0]*x, a[1]*x, a[2]*x); }
+
+void fint(FILE *f, int x) { fwrite(&x, sizeof(x), 1, f); }
+void ffloat(FILE *f, float x) { fwrite(&x, sizeof(x), 1, f); }
+
+void write_table(sn::tabled_inverses& tab, const char *fname) {
+  FILE *f = fopen(fname, "wb");
+  fint(f, tab.PRECX);
+  fint(f, tab.PRECY);
+  fint(f, tab.PRECZ);
+  fwrite(&tab.tab[0], sizeof(ptlow) * tab.PRECX * tab.PRECY * tab.PRECZ, 1, f);
+  fclose(f);
+  }
+
+void alloc_table(sn::tabled_inverses& tab, int X, int Y, int Z) {
+  tab.PRECX = X;
+  tab.PRECY = Y;
+  tab.PRECZ = Z;
+  tab.tab.resize(X*Y*Z);
+  }
+
+ld ptd(ptlow p) {
+  return p[0]*p[0] + p[1]*p[1] + p[2] * p[2];
+  }
+
+void fix_boundaries(sn::tabled_inverses& tab, int last_x, int last_y, int last_z) {
+  int PRECX = tab.PRECX;
+  int PRECY = tab.PRECY;
+  int PRECZ = tab.PRECZ;
+  for(int x=0; x<last_x; x++)
+  for(int y=0; y<last_y; y++) {
+    for(int z=last_z; z<PRECZ; z++)
+      tab.get_int(x,y,z) = tab.get_int(x,y,z-1) * 2 - tab.get_int(x,y,z-2);
+    if(nih)
+      tab.get_int(x,y,0) = tab.get_int(x,y,1) * 2 - tab.get_int(x,y,2);
+    }
+  
+  for(int x=0; x<last_x; x++)
+  for(int y=last_y; y<PRECY; y++)
+  for(int z=0; z<PRECZ; z++)
+    tab.get_int(x,y,z) = tab.get_int(x,y-1,z) * 2 - tab.get_int(x,y-2,z);
+  
+  for(int x=last_x; x<PRECX; x++)
+  for(int y=0; y<PRECY; y++)
+  for(int z=0; z<PRECZ; z++)
+    tab.get_int(x,y,z) = tab.get_int(x-1,y,z) * 2 - tab.get_int(x-2,y,z);
+  }
+
+void build_sols(int PRECX, int PRECY, int PRECZ) {
+  std::mutex file_mutex;
+  ld max_err = 0;
+  auto& tab = sn::get_tabled();
+  alloc_table(tab, PRECX, PRECY, PRECZ);
+  int last_x = PRECX-1, last_y = PRECY-1, last_z = PRECZ-1;
+  auto act = [&] (int tid, int iz) {
+    if((nih && iz == 0) || iz == PRECZ-1) return;
+  
+    auto solve_at = [&] (int ix, int iy) {
+      // if(ix != 30 || iy <= 50 || iz) return;
+      ld x = ix_to_x(ix / (PRECX-1.));
+      ld y = ix_to_x(iy / (PRECY-1.));
+      ld z = iz_to_z(iz / (PRECZ-1.));
+      
+      
+      auto v = hyperpoint ({x,y,z,1});
+      
+      vector<hyperpoint> candidates;
+      hyperpoint cand;
+      
+      candidates.push_back(point3(0,0,0)); 
+      
+      // sort(candidates.begin(), candidates.end(), [&] (hyperpoint a, hyperpoint b) { return solerror(v, direct_exp(a, prec)) > solerror(v, direct_exp(b, prec)); });
+      
+      // cand_best = candidates.back();
+      
+      vector<hyperpoint> solved_candidates;
+      
+      for(auto c: candidates)  {
+        auto solt = iterative_solve(v, c, 1e-6, false);
+        solved_candidates.push_back(solt);
+        if(solerror(v, nisot::numerical_exp(solt)) < 1e-9) break;
+        }
+
+      sort(solved_candidates.begin(), solved_candidates.end(), [&] (hyperpoint a, hyperpoint b) { return solerror(v, nisot::numerical_exp(a)) > solerror(v, nisot::numerical_exp(b)); });
+      
+      cand = solved_candidates.back();
+
+      auto xerr = solerror(v, nisot::numerical_exp(cand));
+      
+      if(cand == fail) {
+        println(hlog, hr::format("[%2d %2d %2d] FAIL", iz, iy, ix));
+        }
+      
+      else if(xerr > 1e-3) {
+        println(hlog, hr::format("[%2d %2d %2d] ", iz, iy, ix));
+        println(hlog, "f(?) = ", v);
+        println(hlog, "f(", cand, ") = ", nisot::numerical_exp(cand));
+        println(hlog, "error = ", xerr);
+        println(hlog, "canned = ", compress(azeq_to_table(cand)));
+        max_err = xerr;
+        return;
+        }
+
+      auto& so = tab.get_int(ix, iy, iz);
+      
+      so = compress(azeq_to_table(cand));
+
+      for(int z=0; z<3; z++) if(isnan(so[z]) || isinf(so[z])) {
+        println(hlog, cand, "canned to ", so);
+        exit(4);
+        }
+      };
+    
+    for(int it=0; it<max(last_x, last_y); it++) {
+      for(int a=0; a<it; a++) {
+        if(it < last_x && a < last_y) solve_at(it, a);
+        if(a < last_x && it < last_y) solve_at(a, it);
+        }
+      if(it < last_x && it < last_y) solve_at(it, it);
+      std::lock_guard<std::mutex> fm(file_mutex);
+      if(0) println(hlog, hr::format("%2d: %2d", iz, it));
+      }
+    };
+
+  parallelize(PRECZ, 0, PRECZ, act);
+  
+  fix_boundaries(tab, last_x, last_y, last_z);
+  }
+
+std::mutex file_mutex_global;
+
+bool deb = false;
+
+hyperpoint find_optimal_geodesic(hyperpoint res) {
+  auto p0 = point3(0, 0, 0);
+  hyperpoint h = iterative_solve(res, p0, 100, 1e-9);
+  if(h == fail) return fail;
+  
+  ld d = hypot_d(3, h);
+  
+  auto solve = [&] (hyperpoint m, pair<hyperpoint, hyperpoint> last) {  
+    hyperpoint t = // inverse_exp(m, iTable, false);
+      iterative_solve(m, last.first, 100, 1e-9);
+    hyperpoint u = // inverse_exp(inverse(nisot::translate(m)) * res, iTable, false);
+      iterative_solve(inverse(nisot::translate(m)) * res, last.second, 100, 1e-6);
+    return make_pair(t, u);
+    };
+    
+  auto quality = [&] (pair<hyperpoint, hyperpoint> p) {
+    return hypot_d(3, p.first) + hypot_d(3, p.second);
+    };
+  
+  auto attempt = [&] (hyperpoint mid) {
+    auto p = solve(mid, {p0, p0});
+    ld qd = quality(p);
+    
+    if(true) {     
+      // println(hlog, "there is something better: ", qd, " vs ", d);
+      
+      bool found;
+      bool failed = false;
+      
+      auto tryit = [&] (hyperpoint h) {
+        auto p2 = solve(h, p);
+        auto qd2 = quality(p2);
+        if(p2.first == fail || p2.second == fail) failed = true;
+        else if(qd2 < qd) {          
+          qd = qd2, p = p2, mid = h;
+          found = true;
+          return true;
+          }
+        return false;
+        };
+      
+      ld delta = 1e-3;
+      
+      /*
+      auto q_x = quality(solve(mid + point3(delta, 0, 0), p)) - qd;
+      auto q_xx = quality(solve(mid + point3(delta+delta, 0, 0), p)) - qd - 2 * q_x;
+      auto q_y = quality(solve(mid + point3(0, delta, 0), p)) - qd;
+      auto q_yy = quality(solve(mid + point3(0, delta+delta, 0), p)) - qd - 2 * q_y;
+      auto q_z = quality(solve(mid + point3(0, 0, delta), p)) - qd;
+      auto q_zz = quality(solve(mid + point3(0, 0, delta+delta), p)) - qd - 2 * q_z;
+      auto q_xy = quality(solve(mid + point3(delta, delta, 0), p)) - qd - q_x - q_y;
+      auto q_xz = quality(solve(mid + point3(delta, 0, delta), p)) - qd - q_x - q_z;
+      auto q_yz = quality(solve(mid + point3(0, delta, delta), p)) - qd - q_y - q_z;
+      
+      transmatrix T = build_matrix(
+        hyperpoint(q_xx, q_xy, q_xz, 0),
+        hyperpoint(q_xy, q_yy, q_yz, 0),
+        hyperpoint(q_xz, q_yz, q_zz, 0),
+        hyperpoint(0, 0, 0, 1)
+        );
+      
+      hyperpoint q = hyperpoint(q_x, q_y, q_z, 0);
+      */
+
+      int itera = 0;
+      
+      while(true) {
+        itera++;
+        if(itera % 1000 == 0) { 
+          std::lock_guard<std::mutex> fm(file_mutex_global);
+          println(hlog, "itera = ", itera); 
+          if(itera >= 5000) return;
+          }
+        auto q_v = quality(solve(mid + point3(delta, -delta, 0), p)) - qd;
+        auto q_vv = quality(solve(mid + point3(delta+delta, -delta-delta, 0), p)) - qd - 2 * q_v;
+        auto q_z = quality(solve(mid + point3(0, 0, delta), p)) - qd;
+        auto q_zz = quality(solve(mid + point3(0, 0, delta+delta), p)) - qd - 2 * q_z;
+        auto q_vz = quality(solve(mid + point3(delta, -delta, delta), p)) - qd - q_v - q_z;
+        
+        ld d = q_vv * q_zz - q_vz * q_vz;
+        if(d == 0 || isnan(d) || isinf(d)) {
+          std::lock_guard<std::mutex> fm(file_mutex_global);
+          println(hlog, "bad matrix in iteration #", itera);
+          println(hlog, "p = ", p, " mid = ", mid);
+          println(hlog, solve(mid, p));
+          return;
+          }
+        
+        transmatrix T = build_matrix(
+          hyperpoint(q_vv, 0, q_vz, 0),
+          hyperpoint(0, 1, 0, 0),
+          hyperpoint(q_vz, 0, q_zz, 0),
+          hyperpoint(0, 0, 0, 1)
+          );
+  
+        hyperpoint q = hyperpoint(q_v, 0, q_z, 0);
+  
+        hyperpoint res = inverse(T) * -q;
+        
+        // println(hlog, "res = ", res);
+  
+        // println(hlog, "check = ", q + T * res);
+        
+        res[1] = -res[0];
+  
+        res = res * delta;
+        
+        res /= 10.;
+        
+        if(tryit(mid + res)) continue;
+        if(tryit(mid + res/2)) continue;
+        if(tryit(mid + res/4)) continue;
+
+        break;
+        }
+
+      // q_x + q_xx * x + q_xy * y + q_xz * z == 0
+      // q + Txyz == 0
+      
+      int it = 0;      
+      
+      ld qd0 = qd;
+      
+      if(false) while(delta > 1e-6) {
+        it++;
+        // if(it % 1000 == 0) println(hlog, "iterations ", it);
+        if(it > 1000) return;
+        if(failed) return;
+        found = false;
+        while(tryit(mid + point3(delta, -delta, 0)));
+        while(tryit(mid + point3(-delta, +delta, 0)));
+        while(tryit(mid + point3(0, 0, delta)));
+        while(tryit(mid + point3(0, 0, -delta)));
+        // while(tryit(mid + point3(delta, delta, 0)));
+        // while(tryit(mid + point3(-delta, -delta, 0)));
+        if(found) println(hlog, "improved further from ", qd0, " to ", qd);
+        if(!found) delta /= 2;
+        }
+      
+      max_iter = 1000;
+      auto h1 = iterative_solve(res, p.first * quality(p) / hypot_d(3, p.first), 100, 1e-6);
+
+      if(deb) println(hlog, "h1 returns ", h1, " of length ", hypot_d(3, h1), " and error ", hypot_d(3, nisot::numerical_exp(h1) - res));
+
+      if(h1 == fail) return;
+      
+      auto d1 = hypot_d(3, h1);
+      if(d1 < d) h = h1, d = d1;
+      }
+    };
+
+  hyperpoint old = h;
+  attempt(point31(res[0], 0, res[2]/2));
+  attempt(point31(0, res[1], res[2]/2));
+
+  std::lock_guard<std::mutex> fm(file_mutex_global);
+  if(h != old && hypot_d(3, h) < hypot_d(3, old) - 1e-5)
+    println(hlog, "new = ", h, " vs old = ", old, " length ", hypot_d(3, h), " vs ", hypot_d(3, old));
+  else if(deb)
+    println(hlog, " not improved: ", old);
+  
+  return h;
+  }
+
+void fix_bugs(sn::tabled_inverses& tab) {
+  auto bug = compress(azeq_to_table(fail));
+  for(int iz=0; iz<tab.PRECZ; iz++) 
+    for(int iy=0; iy<tab.PRECY; iy++)
+      for(int ix=0; ix<tab.PRECX; ix++)  {
+        if(tab.get_int(ix, iy, iz) == bug)
+          for(int a=0; a<3; a++)
+          tab.get_int(ix, iy, iz)[a] = (tab.get_int(ix-1, iy, iz)[a]*2 - tab.get_int(ix-2, iy, iz)[a]);
+        }
+  }
+
+void visualize_table(sn::tabled_inverses& tab, const string& s) {
+  renderbuffer rb(tab.PRECX, tab.PRECY, false);
+  rb.make_surface();
+  
+  for(int iz=0; iz<tab.PRECZ; iz++) {
+    println(hlog, "iz=", iz);
+    for(int iy=0; iy<tab.PRECY; iy++)
+      for(int ix=0; ix<tab.PRECX; ix++)  {
+        auto& p = qpixel(rb.srf, ix, iy);
+        if(ix == 52 && iy >= 30 && iy <= 40 && iz == 15)
+          println(hlog, "A ", tie(ix,iy,iz), " : ", tab.get_int(ix, iy, iz));
+        // println(hlog, ix, ", ", iy);
+        p = 0xFFFFFFFF;
+        for(int i=0; i<3; i++)
+          part(p, i) = 0x80 + 0x70 * tab.get_int(ix, iy, iz)[i];
+        }
+    SDL_SavePNG(rb.srf, hr::format(s.c_str(), iz).c_str());
+    }
+  }
+
+void improve(sn::tabled_inverses& tab) {
+  int PRECX = tab.PRECX;
+  int PRECY = tab.PRECY;
+  int PRECZ = tab.PRECZ;
+  int last_x = PRECX-1, last_y = PRECY-1, last_z = PRECZ-1;
+
+  max_iter = 1000;
+  auto act = [&] (int tid, int iz) {
+    if((nih && iz == 0) || iz == PRECZ-1) return;
+    for(int iy=0; iy<last_y; iy++)
+    for(int ix=0; ix<last_x; ix++) {
+      if(ix < 32 || iy < 32) continue;
+      if(deb) { if(ix < 50 || ix > 54 || iy != 46 || iz != 6) continue; }
+      if(deb) println(hlog, tie(ix, iy, iz), ":");
+      ld x = ix_to_x(ix / (PRECX-1.));
+      ld y = ix_to_x(iy / (PRECY-1.));
+      ld z = iz_to_z(iz / (PRECZ-1.));
+      hyperpoint p = point31(x, y, z);
+      // hyperpoint h1 = inverse_exp(p, iTable, false);
+      hyperpoint h2 = find_optimal_geodesic(p);
+      
+      std::lock_guard<std::mutex> fm(file_mutex_global);
+      if(ix == last_x-1) println(hlog, "solved ", tie(ix, iy, iz));
+      
+      if(h2 != fail) {
+        auto& so = tab.get_int(ix, iy, iz);
+        so = compress(azeq_to_table(h2)); 
+        }
+      }
+    };
+  max_iter = 1000000;
+  
+  parallelize(PRECZ, 0, PRECZ, act);
+  if(deb) exit(7);
+
+
+  fix_boundaries(tab, last_x, last_y, last_z);
+  }
+
+int dimX=64, dimY=64, dimZ=64;
+
+EX hyperpoint recompress(hyperpoint h) { return decompress(compress(h)); }
+
+int readArgs() {
+  using namespace arg;
+           
+  if(0) ;
+  else if(argis("-dim")) {
+    PHASEFROM(2); 
+    shift(); dimX = argi();
+    shift(); dimY = argi();
+    shift(); dimZ = argi();
+    }
+  else if(argis("-build")) {
+    PHASEFROM(2); 
+    build_sols(dimX, dimY, dimZ);
+    }
+  else if(argis("-load-old")) {
+    sn::get_tabled().load();
+    }
+  else if(argis("-improve")) {
+    sn::get_tabled().load();
+    improve(sn::get_tabled());
+    }
+  else if(argis("-write")) {
+    shift();
+    write_table(sn::get_tabled(), argcs());
+    }
+  else if(argis("-fix-bugs")) {
+    sn::get_tabled().load();
+    fix_bugs(sn::get_tabled());
+    }
+  else if(argis("-iz-list")) {
+    sn::get_tabled().load();    
+    for(int iz=0; iz<dimZ-1; iz++)
+      println(hlog, "iz=", iz, " z=", iz_to_z(iz / (dimZ-1.)));
+    }
+  else if(argis("-visualize")) {
+    shift();
+    sn::get_tabled().load();
+    visualize_table(sn::get_tabled(), argcs());
+    }
+  else if(argis("-sn-unittest")) {
+    println(hlog, "nih = ", (bool)nih);
+    ld maxerr;
+    auto test_result = [&maxerr] (ld a, ld b) { maxerr = max(maxerr, (a-b)); };
+    auto test_result_p = [&maxerr] (hyperpoint a, hyperpoint b) { maxerr = max(maxerr, hypot_d(3, a-b)); };
+    auto test = [&maxerr] (string s, reaction_t tester) {
+      maxerr = 0;
+      tester();
+      println(hlog, "unittest: ", s, " error = ", maxerr);
+      };
+    test("x_to_ix", [&] { for(ld a=0; a<=20; a+=.1) test_result(a, sn::ix_to_x(sn::x_to_ix(a))); });
+    test("z_to_iz", [&] { for(ld a=nih?-20:0; a<=20; a+=.1) test_result(a, sn::iz_to_z(sn::z_to_iz(a))); });
+    test("azeq_to_table", [&] { for(ld a=-5; a<=5; a++) for(ld b=-5; b<=5; b++) for(ld c=-5; c<=5; c++) { hyperpoint h = point3(a,b,c); test_result_p(h, sn::table_to_azeq(sn::azeq_to_table(h))); }});
+    test("azeq_to_table recompressed", [&] { 
+      for(ld a=-5; a<=5; a++) for(ld b=-5; b<=5; b++) for(ld c=-5; c<=5; c++) { 
+        hyperpoint h = point3(a,b,c); test_result_p(h, sn::table_to_azeq(recompress(sn::azeq_to_table(h)))); 
+        }
+      });
+    }
+
+  else return 1;
+  return 0;
+  }
+
+auto hook = addHook(hooks_args, 100, readArgs);
+
+}
+}

devmods/tests.cpp

@@ -0,0 +1,132 @@
+#include "../hyper.h"
+#include <iostream>
+#include <thread>
+
+namespace hr {
+
+namespace tests {
+
+int errors = 0;
+
+string test_eq(hyperpoint h1, hyperpoint h2, ld err = 1e-6) {
+  if(sqhypot_d(MDIM, h1 -h2) < err)
+    return lalign(0, "OK ", h1, " ", h2);
+  else {
+    errors++;
+    return lalign(0, "ERROR", " ", h1, " ", h2);
+    }
+  }
+
+string test_eq(transmatrix T1, transmatrix T2, ld err = 1e-6) {
+  if(eqmatrix(T1, T2, err))
+    return "OK";
+  else {
+    errors++;
+    return "ERROR";
+    }
+  }
+
+int readArgs() {
+  using namespace arg;
+           
+  if(0) ;
+  else if(argis("-test-dist")) {
+    start_game();
+    shift(); int d = argi();
+    vector<cell*> l = currentmap->allcells();
+    int unknown = 0;
+    for(cell *c1: l) if(c1->cpdist <= d)
+    for(cell *c2: l) if(c2->cpdist <= d) {
+      int cd = celldistance(c1, c2);
+      int bcd = bounded_celldistance(c1, c2);
+      if(bcd == DISTANCE_UNKNOWN)
+        unknown++;
+      else if(cd != bcd) {
+        errors++;
+        println(hlog, "distance error: ", tie(c1,c2), " cd = ", cd, " bcd = ", bcd);
+        }
+      }
+
+    int q = 0;
+    for(cell *c: l) if(c->cpdist <= d) q++;
+    
+    println(hlog, "cells checked: ", q, " errors: ", errors, " unknown: ", unknown, " in: ", full_geometry_name());
+    
+    if(errors) exit(1);
+    }
+  else if(argis("-test-bt")) {
+    PHASEFROM(3);
+    for(int i=0; i<gGUARD; i++) {
+      eGeometry g = eGeometry(i);      
+      
+      set_geometry(g);
+      ld aer = bt::area_expansion_rate();
+      if(!aer) continue;
+      
+      // if(cgflags & qDEPRECATED) continue;
+      // if(cgflags & qHYBRID) continue;
+      // if(arb::in() || arcm::in()) continue;
+      // if(!(bt::in() || nonisotropic || among(geometry, gEuclidSquare, 
+
+      println(hlog, "testing geometry: ", ginf[g].menu_displayed_name);
+
+      start_game();      
+
+      int co = bt::expansion_coordinate();
+
+      int cx = (co + 1) % WDIM;
+      int cy = (co + 2) % WDIM;
+      auto oxy = [&] (ld x, ld y, ld z) { hyperpoint h = Hypc; h[co] = z; h[cx] = x; if(WDIM == 3) h[cy] = y; return tC0(bt::normalized_at(h)); };
+      ld shrunk_x = geo_dist(oxy(0,0,-1), oxy(.01,0,-1));
+      ld shrunk_y = geo_dist(oxy(0,0,-1), oxy(0,.01,-1));
+      ld expand_x = geo_dist(oxy(0,0,+1), oxy(.01,0,+1));
+      ld expand_y = geo_dist(oxy(0,0,+1), oxy(0,.01,+1));
+      if(WDIM == 2) shrunk_y = expand_y = 1;
+      println(hlog, "should be 1: ", lalign(10, (shrunk_x * shrunk_y * bt::area_expansion_rate()) / (expand_x * expand_y)), " : ", tie(shrunk_x, shrunk_y, expand_x, expand_y, aer));
+      if(geometry == gArnoldCat)
+        println(hlog, "(but not in Arnold's cat)");
+      }
+    }
+  else if(argis("-test-push")) {
+    PHASEFROM(3);
+    for(eGeometry g: {gSol, gNil, gCubeTiling, gSpace534, gCell120}) {
+      stop_game();
+      set_geometry(g);
+      println(hlog, "testing geometry: ", geometry_name());
+      hyperpoint h = hyperpoint(.1, .2, .3, 1);
+      h = normalize(h);
+      println(hlog, "h = ", h);
+      println(hlog, "test rgpushxto0: ", test_eq(rgpushxto0(h) * C0, h));
+      println(hlog, "test gpushxto0: ", test_eq(gpushxto0(h) * h, C0));
+      println(hlog, "test inverses: ", test_eq(inverse(rgpushxto0(h)), gpushxto0(h)));
+      println(hlog, "test iso_inverse: ", test_eq(iso_inverse(rgpushxto0(h)), gpushxto0(h)));
+      }
+    if(errors) exit(1);
+    }
+
+  else if(argis("-partest", [] {
+    hyperpoint h = point31(.01, .05, 0);
+    if(LDIM == 3) h[2] = .015;
+    println(hlog, "h = ", h);
+    println(hlog, "good Ph = ", parabolic13(h));
+    println(hlog, "good DPh = ", test_eq(h, deparabolic13(parabolic13(h))));
+    // println(hlog, "bad Ph = ", parabolic10(h));
+    // println(hlog, "bad DPh = ", test_eq(h, deparabolic10(parabolic10(h))));
+    if(LDIM == 3) {
+      println(hlog, "min Ph = ", bt::bt_to_minkowski(h));
+      println(hlog, "min DPh = ", test_eq(h, bt::minkowski_to_bt(bt::bt_to_minkowski(h))));
+      }
+    });
+
+  else return 1;
+  return 0;
+  }
+
+auto hooks = addHook(hooks_args, 100, readArgs);
+ 
+// Bolza:: genus 2 => Euler characteristic -2
+// octagon: -2/6
+// ~> 6 octagons
+
+}
+}

earcut.hpp

@@ -0,0 +1,799 @@
+/*
+ISC License
+
+Copyright (c) 2015, Mapbox
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <memory>
+#include <vector>
+
+namespace mapbox {
+
+namespace util {
+
+template <std::size_t I, typename T> struct nth {
+    inline static typename std::tuple_element<I, T>::type
+    get(const T& t) { return std::get<I>(t); }
+};
+
+}
+
+namespace detail {
+
+template <typename N = uint32_t>
+class Earcut {
+public:
+    std::vector<N> indices;
+    std::size_t vertices;
+
+    template <typename Polygon>
+    void operator()(const Polygon& points);
+    
+    Earcut() { vertices = 0; inv_size = 0; }
+
+private:
+    struct Node {
+        Node(N index, double x_, double y_) : i(index), x(x_), y(y_) { z = 0; prev = nullptr; next = nullptr; prevZ = nextZ = nullptr; steiner = false; }
+        Node(const Node&) = delete;
+        Node& operator=(const Node&) = delete;
+        Node(Node&&) = delete;
+        Node& operator=(Node&&) = delete;
+
+        const N i;
+        const double x;
+        const double y;
+
+        // previous and next vertice nodes in a polygon ring
+        Node* prev;
+        Node* next;
+
+        // z-order curve value
+        int32_t z;
+
+        // previous and next nodes in z-order
+        Node* prevZ;
+        Node* nextZ;
+
+        // indicates whether this is a steiner point
+        bool steiner; 
+    };
+
+    template <typename Ring> Node* linkedList(const Ring& points, const bool clockwise);
+    Node* filterPoints(Node* start, Node* end = nullptr);
+    void earcutLinked(Node* ear, int pass = 0);
+    bool isEar(Node* ear);
+    bool isEarHashed(Node* ear);
+    Node* cureLocalIntersections(Node* start);
+    void splitEarcut(Node* start);
+    template <typename Polygon> Node* eliminateHoles(const Polygon& points, Node* outerNode);
+    void eliminateHole(Node* hole, Node* outerNode);
+    Node* findHoleBridge(Node* hole, Node* outerNode);
+    void indexCurve(Node* start);
+    Node* sortLinked(Node* list);
+    int32_t zOrder(const double x_, const double y_);
+    Node* getLeftmost(Node* start);
+    bool pointInTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py) const;
+    bool isValidDiagonal(Node* a, Node* b);
+    double area(const Node* p, const Node* q, const Node* r) const;
+    bool equals(const Node* p1, const Node* p2);
+    bool intersects(const Node* p1, const Node* q1, const Node* p2, const Node* q2);
+    bool intersectsPolygon(const Node* a, const Node* b);
+    bool locallyInside(const Node* a, const Node* b);
+    bool middleInside(const Node* a, const Node* b);
+    Node* splitPolygon(Node* a, Node* b);
+    template <typename Point> Node* insertNode(std::size_t i, const Point& p, Node* last);
+    void removeNode(Node* p);
+
+    bool hashing;
+    double minX, maxX;
+    double minY, maxY;
+    double inv_size;
+
+    template <typename T> // , typename Alloc = std::allocator<T>>
+    class ObjectPool {
+    public:
+        ObjectPool() { currentIndex = blockSize = 1; currentBlock = nullptr; }
+        ObjectPool(std::size_t blockSize_) {
+            reset(blockSize_);
+        }
+        ~ObjectPool() {
+            clear();
+        }
+        template <typename... Args>
+        T* construct(Args&&... args) {
+            if (currentIndex >= blockSize) {
+                currentBlock = (T*) new char[sizeof(T) * blockSize];
+                // alloc_traits::allocate(alloc, blockSize);
+                allocations.emplace_back(currentBlock);
+                currentIndex = 0;
+            }
+            T* object = &currentBlock[currentIndex++];
+            // alloc_traits::construct(alloc, object, std::forward<Args>(args)...);
+            ::new (static_cast<void*>(object)) T(std::forward<Args>(args)...);
+            return object;
+        }
+        void reset(std::size_t newBlockSize) {
+            for (auto allocation : allocations) {
+                // alloc_traits::deallocate(alloc, allocation, blockSize);                
+                delete[] allocation;
+            }
+            allocations.clear();
+            blockSize = std::max<std::size_t>(1, newBlockSize);
+            currentBlock = nullptr;
+            currentIndex = blockSize;
+        }
+        void clear() { reset(blockSize); }
+    private:
+        T* currentBlock;
+        std::size_t currentIndex;
+        std::size_t blockSize;
+        std::vector<T*> allocations;
+        // Alloc alloc;
+        // typedef typename std::allocator_traits<Alloc> alloc_traits;
+    };
+    ObjectPool<Node> nodes;
+};
+
+template <typename N> template <typename Polygon>
+void Earcut<N>::operator()(const Polygon& points) {
+    // reset
+    indices.clear();
+    vertices = 0;
+
+    if (points.empty()) return;
+
+    double x;
+    double y;
+    int threshold = 80;
+    std::size_t len = 0;
+
+    for (size_t i = 0; threshold >= 0 && i < points.size(); i++) {
+        threshold -= static_cast<int>(points[i].size());
+        len += points[i].size();
+    }
+
+    //estimate size of nodes and indices
+    nodes.reset(len * 3 / 2);
+    indices.reserve(len + points[0].size());
+
+    Node* outerNode = linkedList(points[0], true);
+    if (!outerNode || outerNode->prev == outerNode->next) return;
+
+    if (points.size() > 1) outerNode = eliminateHoles(points, outerNode);
+
+    // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
+    hashing = threshold < 0;
+    if (hashing) {
+        Node* p = outerNode->next;
+        minX = maxX = outerNode->x;
+        minY = maxY = outerNode->y;
+        do {
+            x = p->x;
+            y = p->y;
+            minX = std::min<double>(minX, x);
+            minY = std::min<double>(minY, y);
+            maxX = std::max<double>(maxX, x);
+            maxY = std::max<double>(maxY, y);
+            p = p->next;
+        } while (p != outerNode);
+
+        // minX, minY and size are later used to transform coords into integers for z-order calculation
+        inv_size = std::max<double>(maxX - minX, maxY - minY);
+        inv_size = inv_size != .0 ? (1. / inv_size) : .0;
+    }
+
+    earcutLinked(outerNode);
+
+    nodes.clear();
+}
+
+// create a circular doubly linked list from polygon points in the specified winding order
+template <typename N> template <typename Ring>
+typename Earcut<N>::Node*
+Earcut<N>::linkedList(const Ring& points, const bool clockwise) {
+    typedef typename Ring::value_type Point;
+    double sum = 0;
+    const std::size_t len = points.size();
+    std::size_t i, j;
+    Node* last = nullptr;
+
+    // calculate original winding order of a polygon ring
+    for (i = 0, j = len > 0 ? len - 1 : 0; i < len; j = i++) {
+        const auto& p1 = points[i];
+        const auto& p2 = points[j];
+        const double p20 = util::nth<0, Point>::get(p2);
+        const double p10 = util::nth<0, Point>::get(p1);
+        const double p11 = util::nth<1, Point>::get(p1);
+        const double p21 = util::nth<1, Point>::get(p2);
+        sum += (p20 - p10) * (p11 + p21);
+    }
+
+    // link points into circular doubly-linked list in the specified winding order
+    if (clockwise == (sum > 0)) {
+        for (i = 0; i < len; i++) last = insertNode(vertices + i, points[i], last);
+    } else {
+        for (i = len; i-- > 0;) last = insertNode(vertices + i, points[i], last);
+    }
+
+    if (last && equals(last, last->next)) {
+        removeNode(last);
+        last = last->next;
+    }
+
+    vertices += len;
+
+    return last;
+}
+
+// eliminate colinear or duplicate points
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::filterPoints(Node* start, Node* end) {
+    if (!end) end = start;
+
+    Node* p = start;
+    bool again;
+    do {
+        again = false;
+
+        if (!p->steiner && (equals(p, p->next) || area(p->prev, p, p->next) == 0)) {
+            removeNode(p);
+            p = end = p->prev;
+
+            if (p == p->next) break;
+            again = true;
+
+        } else {
+            p = p->next;
+        }
+    } while (again || p != end);
+
+    return end;
+}
+
+// main ear slicing loop which triangulates a polygon (given as a linked list)
+template <typename N>
+void Earcut<N>::earcutLinked(Node* ear, int pass) {
+    if (!ear) return;
+
+    // interlink polygon nodes in z-order
+    if (!pass && hashing) indexCurve(ear);
+
+    Node* stop = ear;
+    Node* prev;
+    Node* next;
+
+    int iterations = 0;
+
+    // iterate through ears, slicing them one by one
+    while (ear->prev != ear->next) {
+        iterations++;
+        prev = ear->prev;
+        next = ear->next;
+
+        if (hashing ? isEarHashed(ear) : isEar(ear)) {
+            // cut off the triangle
+            indices.emplace_back(prev->i);
+            indices.emplace_back(ear->i);
+            indices.emplace_back(next->i);
+
+            removeNode(ear);
+
+            // skipping the next vertice leads to less sliver triangles
+            ear = next->next;
+            stop = next->next;
+
+            continue;
+        }
+
+        ear = next;
+
+        // if we looped through the whole remaining polygon and can't find any more ears
+        if (ear == stop) {
+            // try filtering points and slicing again
+            if (!pass) earcutLinked(filterPoints(ear), 1);
+
+            // if this didn't work, try curing all small self-intersections locally
+            else if (pass == 1) {
+                ear = cureLocalIntersections(ear);
+                earcutLinked(ear, 2);
+
+            // as a last resort, try splitting the remaining polygon into two
+            } else if (pass == 2) splitEarcut(ear);
+
+            break;
+        }
+    }
+}
+
+// check whether a polygon node forms a valid ear with adjacent nodes
+template <typename N>
+bool Earcut<N>::isEar(Node* ear) {
+    const Node* a = ear->prev;
+    const Node* b = ear;
+    const Node* c = ear->next;
+
+    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+
+    // now make sure we don't have other points inside the potential ear
+    Node* p = ear->next->next;
+
+    while (p != ear->prev) {
+        if (pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
+            area(p->prev, p, p->next) >= 0) return false;
+        p = p->next;
+    }
+
+    return true;
+}
+
+template <typename N>
+bool Earcut<N>::isEarHashed(Node* ear) {
+    const Node* a = ear->prev;
+    const Node* b = ear;
+    const Node* c = ear->next;
+
+    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+
+    // triangle bbox; min & max are calculated like this for speed
+    const double minTX = std::min<double>(a->x, std::min<double>(b->x, c->x));
+    const double minTY = std::min<double>(a->y, std::min<double>(b->y, c->y));
+    const double maxTX = std::max<double>(a->x, std::max<double>(b->x, c->x));
+    const double maxTY = std::max<double>(a->y, std::max<double>(b->y, c->y));
+
+    // z-order range for the current triangle bbox;
+    const int32_t minZ = zOrder(minTX, minTY);
+    const int32_t maxZ = zOrder(maxTX, maxTY);
+
+    // first look for points inside the triangle in increasing z-order
+    Node* p = ear->nextZ;
+
+    while (p && p->z <= maxZ) {
+        if (p != ear->prev && p != ear->next &&
+            pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
+            area(p->prev, p, p->next) >= 0) return false;
+        p = p->nextZ;
+    }
+
+    // then look for points in decreasing z-order
+    p = ear->prevZ;
+
+    while (p && p->z >= minZ) {
+        if (p != ear->prev && p != ear->next &&
+            pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
+            area(p->prev, p, p->next) >= 0) return false;
+        p = p->prevZ;
+    }
+
+    return true;
+}
+
+// go through all polygon nodes and cure small local self-intersections
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::cureLocalIntersections(Node* start) {
+    Node* p = start;
+    do {
+        Node* a = p->prev;
+        Node* b = p->next->next;
+
+        // a self-intersection where edge (v[i-1],v[i]) intersects (v[i+1],v[i+2])
+        if (!equals(a, b) && intersects(a, p, p->next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+            indices.emplace_back(a->i);
+            indices.emplace_back(p->i);
+            indices.emplace_back(b->i);
+
+            // remove two nodes involved
+            removeNode(p);
+            removeNode(p->next);
+
+            p = start = b;
+        }
+        p = p->next;
+    } while (p != start);
+
+    return p;
+}
+
+// try splitting polygon into two and triangulate them independently
+template <typename N>
+void Earcut<N>::splitEarcut(Node* start) {
+    // look for a valid diagonal that divides the polygon into two
+    Node* a = start;
+    do {
+        Node* b = a->next->next;
+        while (b != a->prev) {
+            if (a->i != b->i && isValidDiagonal(a, b)) {
+                // split the polygon in two by the diagonal
+                Node* c = splitPolygon(a, b);
+
+                // filter colinear points around the cuts
+                a = filterPoints(a, a->next);
+                c = filterPoints(c, c->next);
+
+                // run earcut on each half
+                earcutLinked(a);
+                earcutLinked(c);
+                return;
+            }
+            b = b->next;
+        }
+        a = a->next;
+    } while (a != start);
+}
+
+// link every hole into the outer loop, producing a single-ring polygon without holes
+template <typename N> template <typename Polygon>
+typename Earcut<N>::Node*
+Earcut<N>::eliminateHoles(const Polygon& points, Node* outerNode) {
+    const size_t len = points.size();
+
+    std::vector<Node*> queue;
+    for (size_t i = 1; i < len; i++) {
+        Node* list = linkedList(points[i], false);
+        if (list) {
+            if (list == list->next) list->steiner = true;
+            queue.push_back(getLeftmost(list));
+        }
+    }
+    std::sort(queue.begin(), queue.end(), [](const Node* a, const Node* b) {
+        return a->x < b->x;
+    });
+
+    // process holes from left to right
+    for (size_t i = 0; i < queue.size(); i++) {
+        eliminateHole(queue[i], outerNode);
+        outerNode = filterPoints(outerNode, outerNode->next);
+    }
+
+    return outerNode;
+}
+
+// find a bridge between vertices that connects hole with an outer ring and and link it
+template <typename N>
+void Earcut<N>::eliminateHole(Node* hole, Node* outerNode) {
+    outerNode = findHoleBridge(hole, outerNode);
+    if (outerNode) {
+        Node* b = splitPolygon(outerNode, hole);
+        filterPoints(b, b->next);
+    }
+}
+
+// David Eberly's algorithm for finding a bridge between hole and outer polygon
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::findHoleBridge(Node* hole, Node* outerNode) {
+    Node* p = outerNode;
+    double hx = hole->x;
+    double hy = hole->y;
+    double qx = -std::numeric_limits<double>::infinity();
+    Node* m = nullptr;
+
+    // find a segment intersected by a ray from the hole's leftmost Vertex to the left;
+    // segment's endpoint with lesser x will be potential connection Vertex
+    do {
+        if (hy <= p->y && hy >= p->next->y && p->next->y != p->y) {
+          double x = p->x + (hy - p->y) * (p->next->x - p->x) / (p->next->y - p->y);
+          if (x <= hx && x > qx) {
+            qx = x;
+            if (x == hx) {
+                if (hy == p->y) return p;
+                if (hy == p->next->y) return p->next;
+            }
+            m = p->x < p->next->x ? p : p->next;
+          }
+        }
+        p = p->next;
+    } while (p != outerNode);
+
+    if (!m) return 0;
+
+    if (hx == qx) return m->prev;
+
+    // look for points inside the triangle of hole Vertex, segment intersection and endpoint;
+    // if there are no points found, we have a valid connection;
+    // otherwise choose the Vertex of the minimum angle with the ray as connection Vertex
+
+    const Node* stop = m;
+    double tanMin = std::numeric_limits<double>::infinity();
+    double tanCur = 0;
+
+    p = m->next;
+    double mx = m->x;
+    double my = m->y;
+
+    while (p != stop) {
+        if (hx >= p->x && p->x >= mx && hx != p->x &&
+            pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p->x, p->y)) {
+
+            tanCur = std::abs(hy - p->y) / (hx - p->x); // tangential
+
+            if ((tanCur < tanMin || (tanCur == tanMin && p->x > m->x)) && locallyInside(p, hole)) {
+                m = p;
+                tanMin = tanCur;
+            }
+        }
+
+        p = p->next;
+    }
+
+    return m;
+}
+
+// interlink polygon nodes in z-order
+template <typename N>
+void Earcut<N>::indexCurve(Node* start) {
+    assert(start);
+    Node* p = start;
+
+    do {
+        p->z = p->z ? p->z : zOrder(p->x, p->y);
+        p->prevZ = p->prev;
+        p->nextZ = p->next;
+        p = p->next;
+    } while (p != start);
+
+    p->prevZ->nextZ = nullptr;
+    p->prevZ = nullptr;
+
+    sortLinked(p);
+}
+
+// Simon Tatham's linked list merge sort algorithm
+// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::sortLinked(Node* list) {
+    assert(list);
+    Node* p;
+    Node* q;
+    Node* e;
+    Node* tail;
+    int i, numMerges, pSize, qSize;
+    int inSize = 1;
+
+    for (;;) {
+        p = list;
+        list = nullptr;
+        tail = nullptr;
+        numMerges = 0;
+
+        while (p) {
+            numMerges++;
+            q = p;
+            pSize = 0;
+            for (i = 0; i < inSize; i++) {
+                pSize++;
+                q = q->nextZ;
+                if (!q) break;
+            }
+
+            qSize = inSize;
+
+            while (pSize > 0 || (qSize > 0 && q)) {
+
+                if (pSize == 0) {
+                    e = q;
+                    q = q->nextZ;
+                    qSize--;
+                } else if (qSize == 0 || !q) {
+                    e = p;
+                    p = p->nextZ;
+                    pSize--;
+                } else if (p->z <= q->z) {
+                    e = p;
+                    p = p->nextZ;
+                    pSize--;
+                } else {
+                    e = q;
+                    q = q->nextZ;
+                    qSize--;
+                }
+
+                if (tail) tail->nextZ = e;
+                else list = e;
+
+                e->prevZ = tail;
+                tail = e;
+            }
+
+            p = q;
+        }
+
+        tail->nextZ = nullptr;
+
+        if (numMerges <= 1) return list;
+
+        inSize *= 2;
+    }
+}
+
+// z-order of a Vertex given coords and size of the data bounding box
+template <typename N>
+int32_t Earcut<N>::zOrder(const double x_, const double y_) {
+    // coords are transformed into non-negative 15-bit integer range
+    int32_t x = static_cast<int32_t>(32767.0 * (x_ - minX) * inv_size);
+    int32_t y = static_cast<int32_t>(32767.0 * (y_ - minY) * inv_size);
+
+    x = (x | (x << 8)) & 0x00FF00FF;
+    x = (x | (x << 4)) & 0x0F0F0F0F;
+    x = (x | (x << 2)) & 0x33333333;
+    x = (x | (x << 1)) & 0x55555555;
+
+    y = (y | (y << 8)) & 0x00FF00FF;
+    y = (y | (y << 4)) & 0x0F0F0F0F;
+    y = (y | (y << 2)) & 0x33333333;
+    y = (y | (y << 1)) & 0x55555555;
+
+    return x | (y << 1);
+}
+
+// find the leftmost node of a polygon ring
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::getLeftmost(Node* start) {
+    Node* p = start;
+    Node* leftmost = start;
+    do {
+        if (p->x < leftmost->x || (p->x == leftmost->x && p->y < leftmost->y))
+            leftmost = p;
+        p = p->next;
+    } while (p != start);
+
+    return leftmost;
+}
+
+// check if a point lies within a convex triangle
+template <typename N>
+bool Earcut<N>::pointInTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py) const {
+    return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
+           (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
+           (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
+}
+
+// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
+template <typename N>
+bool Earcut<N>::isValidDiagonal(Node* a, Node* b) {
+    return a->next->i != b->i && a->prev->i != b->i && !intersectsPolygon(a, b) &&
+           locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b);
+}
+
+// signed area of a triangle
+template <typename N>
+double Earcut<N>::area(const Node* p, const Node* q, const Node* r) const {
+    return (q->y - p->y) * (r->x - q->x) - (q->x - p->x) * (r->y - q->y);
+}
+
+// check if two points are equal
+template <typename N>
+bool Earcut<N>::equals(const Node* p1, const Node* p2) {
+    return p1->x == p2->x && p1->y == p2->y;
+}
+
+// check if two segments intersect
+template <typename N>
+bool Earcut<N>::intersects(const Node* p1, const Node* q1, const Node* p2, const Node* q2) {
+    if ((equals(p1, q1) && equals(p2, q2)) ||
+        (equals(p1, q2) && equals(p2, q1))) return true;
+    return (area(p1, q1, p2) > 0) != (area(p1, q1, q2) > 0) &&
+           (area(p2, q2, p1) > 0) != (area(p2, q2, q1) > 0);
+}
+
+// check if a polygon diagonal intersects any polygon segments
+template <typename N>
+bool Earcut<N>::intersectsPolygon(const Node* a, const Node* b) {
+    const Node* p = a;
+    do {
+        if (p->i != a->i && p->next->i != a->i && p->i != b->i && p->next->i != b->i &&
+                intersects(p, p->next, a, b)) return true;
+        p = p->next;
+    } while (p != a);
+
+    return false;
+}
+
+// check if a polygon diagonal is locally inside the polygon
+template <typename N>
+bool Earcut<N>::locallyInside(const Node* a, const Node* b) {
+    return area(a->prev, a, a->next) < 0 ?
+        area(a, b, a->next) >= 0 && area(a, a->prev, b) >= 0 :
+        area(a, b, a->prev) < 0 || area(a, a->next, b) < 0;
+}
+
+// check if the middle Vertex of a polygon diagonal is inside the polygon
+template <typename N>
+bool Earcut<N>::middleInside(const Node* a, const Node* b) {
+    const Node* p = a;
+    bool inside = false;
+    double px = (a->x + b->x) / 2;
+    double py = (a->y + b->y) / 2;
+    do {
+        if (((p->y > py) != (p->next->y > py)) && p->next->y != p->y &&
+                (px < (p->next->x - p->x) * (py - p->y) / (p->next->y - p->y) + p->x))
+            inside = !inside;
+        p = p->next;
+    } while (p != a);
+
+    return inside;
+}
+
+// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits
+// polygon into two; if one belongs to the outer ring and another to a hole, it merges it into a
+// single ring
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::splitPolygon(Node* a, Node* b) {
+    Node* a2 = nodes.construct(a->i, a->x, a->y);
+    Node* b2 = nodes.construct(b->i, b->x, b->y);
+    Node* an = a->next;
+    Node* bp = b->prev;
+
+    a->next = b;
+    b->prev = a;
+
+    a2->next = an;
+    an->prev = a2;
+
+    b2->next = a2;
+    a2->prev = b2;
+
+    bp->next = b2;
+    b2->prev = bp;
+
+    return b2;
+}
+
+// create a node and util::optionally link it with previous one (in a circular doubly linked list)
+template <typename N> template <typename Point>
+typename Earcut<N>::Node*
+Earcut<N>::insertNode(std::size_t i, const Point& pt, Node* last) {
+    Node* p = nodes.construct(static_cast<N>(i), util::nth<0, Point>::get(pt), util::nth<1, Point>::get(pt));
+
+    if (!last) {
+        p->prev = p;
+        p->next = p;
+
+    } else {
+        assert(last);
+        p->next = last->next;
+        p->prev = last;
+        last->next->prev = p;
+        last->next = p;
+    }
+    return p;
+}
+
+template <typename N>
+void Earcut<N>::removeNode(Node* p) {
+    p->next->prev = p->prev;
+    p->prev->next = p->next;
+
+    if (p->prevZ) p->prevZ->nextZ = p->nextZ;
+    if (p->nextZ) p->nextZ->prevZ = p->prevZ;
+}
+}
+
+template <typename N = uint32_t, typename Polygon>
+std::vector<N> earcut(const Polygon& poly) {
+    mapbox::detail::Earcut<N> earcut;
+    earcut(poly);
+    return std::move(earcut.indices);
+}
+}

embuild.sh

@@ -1,3 +1,3 @@
 #!/bin/sh
-/usr/lib/emscripten/em++ hyperweb.cpp -O3 -s LEGACY_GL_EMULATION=1 -s TOTAL_MEMORY=128*1024*1024 -std=c++11 -o hyper.html
+/usr/lib/emscripten/em++ hyperweb.cpp -O3 -s USE_ZLIB=1 -s LEGACY_GL_EMULATION=1 -s TOTAL_MEMORY=128*1024*1024 -std=c++11 -o hyper.html
 

environment.cpp

@@ -0,0 +1,934 @@
+// Hyperbolic Rogue - environment
+// Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details
+
+/** \file environment.cpp
+ *  \brief game environment: routines related to the game that affect all the map. Monsters to move are detected here, but their moves are implemented in monstermove.cpp
+ */
+
+#include "hyper.h"
+
+namespace hr {
+
+#if HDR
+#define HF_BUG        Flag(0)
+#define HF_EARTH      Flag(1)
+#define HF_BIRD       Flag(2)
+#define HF_LEADER     Flag(3)
+#define HF_HEX        Flag(4)
+#define HF_WHIRLPOOL  Flag(5)
+#define HF_WATER      Flag(6)
+#define HF_AIR        Flag(7)
+#define HF_MUTANT     Flag(8)
+#define HF_OUTLAW     Flag(9)
+#define HF_WHIRLWIND  Flag(10)
+#define HF_ROSE       Flag(11)
+#define HF_DRAGON     Flag(12)
+#define HF_KRAKEN     Flag(13)
+#define HF_SHARK      Flag(14)
+#define HF_BATS       Flag(15)
+#define HF_REPTILE    Flag(16)
+#define HF_EAGLES     Flag(17)
+#define HF_SLOW       Flag(18)
+#define HF_FAST       Flag(19)
+#define HF_WARP       Flag(20)
+#define HF_MOUSE      Flag(21)
+#define HF_RIVER      Flag(22)
+#define HF_MIRROR     Flag(23)
+#define HF_VOID       Flag(24)
+#define HF_HUNTER     Flag(25)
+#define HF_FAILED_AMBUSH     Flag(26)
+#define HF_MAGNET     Flag(27)
+#define HF_HEXD       Flag(28)
+#define HF_ALT        Flag(29)
+#define HF_MONK       Flag(30)
+#define HF_WESTWALL   Flag(31)
+#define HF_JUMP       Flag(32)
+#define HF_DICE       Flag(33)
+#endif
+
+EX flagtype havewhat, hadwhat;
+
+/** monsters of specific types to move */
+EX vector<cell*> worms, ivies, ghosts, golems, hexsnakes;
+
+/** temporary changes during bfs */
+vector<pair<cell*, eMonster>> tempmonsters;
+
+/** The position of the first cell in dcal in distance 7. New wandering monsters can be generated in dcal[first7..]. */
+EX int first7;           
+
+/** the list of all nearby cells, according to cpdist */
+EX vector<cell*> dcal;
+
+/** the list of all nearby cells, according to current pathdist */
+EX vector<cellwalker> pathq;
+
+/** the number of big statues -- they increase monster generation */
+EX int statuecount;
+
+/** the number of slimes in Wetland -- they create ghosts */
+EX int wetslime;
+
+/** list of monsters to move (pathq restriced to monsters) */
+EX vector<cell*> pathqm;
+
+/** which hex snakes are there */
+EX set<int> snaketypes;
+
+EX int gamerange_bonus = 0;
+EX int gamerange() { return getDistLimit() + gamerange_bonus; }
+
+// pathdist begin
+EX cell *pd_from;
+EX int pd_range;
+
+#if HDR
+/** The pathdata is used to keep a list of visited cells. It is used as follows:
+ *  1) create pathdata object: pathdata pd(identifier)
+ *  2) use one of the following methods to mark cells as visited:
+ *  2a) onpath_with_dir or onpath_random_dir, to mark a cell together with its distance and the direction we came from (used by computePathdist to make pathfinding not sensitive to direction indexing)
+ *  2b) onpath, to mark a cell at its distance (used when ordering is irrelevant: compute_graphical_distance and in shmup)
+ *  2c) onpatk_mark, to just mark a cell (used in groupmove2)
+ *  3) All the visited cells are listed in pathq, and they have 'pathdist' set to their recorded distance (0 in case of onpath_mark).
+ *  4) When the pathdata object is deleted, all the pathdist values are cleared back to PINFD.
+ *  The variable 'pathlock' ensures that we do not use two pathdata objects at once.
+ **/
+
+struct pathdata {
+  void checklock();
+  ~pathdata();
+  pathdata(eMonster m, bool include_allies IS(true));
+  pathdata(int i);
+  };
+#endif
+
+/** using pathdata, record a cell (together with direction) as visited */
+EX void onpath_with_dir(cellwalker cw, int d) {
+  if(!pathlock) {
+    println(hlog, "onpath(", cw, ", ", d, ") without pathlock");
+    }
+  cw.at->pathdist = d;
+  pathq.push_back(cw);
+  }
+
+/** using pathdata, record a cell as visited, with random direction */
+EX void onpath_random_dir(cell *c, int d) {
+  onpath_with_dir(cellwalker(c, hrand(c->type), hrand(2)), d);
+  }
+
+EX void onpath(cell *c, int d) {
+  onpath_with_dir(cellwalker(c, 0, 0), d);
+  }
+
+EX void onpath_mark(cell *c) {
+  onpath_with_dir(cellwalker(c, 0, 0), 0);
+  }
+
+EX void clear_pathdata() {
+  for(auto c: pathq) c.at->pathdist = PINFD;
+  pathq.clear(); 
+  pathqm.clear();
+  }
+
+/** This ensures that we do not use two pathdata objects at once */
+EX int pathlock = 0;
+
+/** compute_graphical_distance determines the distance of every cell
+ *  from the current FOV center. It uses the pathq structures but
+ *  does not lock them */
+
+EX void compute_graphical_distance() {
+  if(pathlock) { printf("path error: compute_graphical_distance\n"); }
+  cell *c1 = centerover ? centerover : pd_from ? pd_from : cwt.at;
+  int sr = get_sightrange_ambush();
+  if(pd_from == c1 && pd_range == sr) return;
+  clear_pathdata();
+  
+  pathlock++;
+  pd_from = c1;
+  pd_range = sr;
+  onpath(c1, 0);
+
+  for(int qb=0; qb<isize(pathq); qb++) {
+    cell *c = pathq[qb].at;
+    if(c->pathdist == pd_range) break;
+    if(qb == 0) forCellCM(c1, c) ;
+    forCellEx(c1, c)
+      if(c1->pathdist == PINFD)
+        onpath(c1, c->pathdist + 1);
+    }
+
+  pathlock--;
+  }
+
+const int max_radius = 16;
+
+struct visit_set {
+  set<cell*> visited;
+  queue<cell*> q;
+  void visit(cell *c) {
+    if(visited.count(c)) return;
+    visited.insert(c);
+    q.push(c);
+    }
+  };
+
+struct princess_ai {
+  array<visit_set, max_radius+1> info;
+  void visit_gate(cell *g) { info[0].visit(g); }
+  void run();
+  };
+
+void princess_ai::run() {
+  int radius = toggle_radius(waOpenPlate);
+  if(pathq.empty()) return;
+  int d = pathq.back().at->pathdist;
+  if(d == PINFD - 1) return;
+  d++;
+  if(d < 5) d = 5; /* the Princess AI avoids plates when too close to the player */
+  hassert(radius <= max_radius);
+
+  for(int k=0; k<=radius; k++) while(!info[k].q.empty()) {
+    cell *c = info[k].q.front();
+    info[k].q.pop();
+    if(k < radius) forCellEx(c1, c) {
+      info[k+1].visit(c1);
+      if(k == 0 && c1->wall == waClosedGate)
+        info[0].visit(c1);
+      }
+    if(k == radius && c->wall == waOpenPlate && c->pathdist == PINFD)
+      onpath_random_dir(c, d);
+    }
+  }
+
+EX void computePathdist(eMonster param, bool include_allies IS(true)) {
+  
+  for(cell *c: targets)
+    if(include_allies || isPlayerOn(c))
+      onpath_random_dir(c, isPlayerOn(c) ? 0 : 1);
+
+  int qtarg = isize(targets);
+  
+  int limit = gamerange();
+  
+  int qb = 0;
+
+  bool princess = isPrincess(param);
+  princess_ai gd;
+  princess_retry:
+  
+  for(; qb < isize(pathq); qb++) {
+    cellwalker cw = pathq[qb];
+    /* The opposite cell will be added to the queue first, which helps the AI. */
+    cw += cw.at->type/2;
+    cell*& c = cw.at;
+    if(c->monst && !isBug(c) && !(isFriendly(c) && !c->stuntime)) {
+      pathqm.push_back(c); 
+      continue; // no paths going through monsters
+      }
+    if(isMounted(c) && !isPlayerOn(c)) {
+      // don't treat the Worm you are riding as passable
+      pathqm.push_back(c); 
+      continue; 
+      }
+    if(c->cpdist > limit && !(c->land == laTrollheim && turncount < c->landparam) && c->wall != waThumperOn) continue;
+    int d = c->pathdist;
+    if(d == PINFD - 1) continue;
+    for(int j=0; j<c->type; j++) {
+      cellwalker cw1 = cw + j;
+      // printf("i=%d cd=%d\n", i, c->move(i)->cpdist);
+      cell *c2 = cw1.peek();
+      
+      flagtype f = P_MONSTER;
+      if(param == moTameBomberbird) f |= P_FLYING | P_ISFRIEND;
+      if(isPrincess(param)) f |= P_ISFRIEND | P_USEBOAT | P_CHAIN;
+      if(param == moGolem) f |= P_ISFRIEND;
+      bool pass = c2 && c2->pathdist == PINFD;
+      if(pass && qb < qtarg && !nonAdjacent(c, c2) && !thruVine(c,c2)) pass = passable(c2, NULL, f);
+      else pass = pass && passable(c, c2, f);
+
+      if(pass) {
+        
+        if(qb >= qtarg) {
+          if(param == moTortoise && nogoSlow(c, c2)) continue;
+          if(param == moIvyRoot  && strictlyAgainstGravity(c, c2, false, MF_IVY)) continue;
+          if(param == moWorm && (cellUnstable(c) || cellEdgeUnstable(c) || prairie::no_worms(c))) continue;
+          if(!isFriendly(param) && items[itOrbLava] && c2->cpdist <= 5 && pseudohept(c) && makeflame(c2, 1, true))
+            continue;
+          }
+
+        onpath_with_dir(cw1 + wstep, d+1);
+        }
+      
+      else if(c2 && c2->wall == waClosedGate && princess)
+        gd.visit_gate(c2);
+      }
+    }
+  
+  if(princess) {
+    gd.run(); 
+    if(qb < isize(pathq)) goto princess_retry;
+    }
+  }
+
+pathdata::~pathdata() {
+  pathlock--;
+  clear_pathdata();
+  }
+
+void pathdata::checklock() {
+  if(pd_from) pd_from = NULL, clear_pathdata();
+  if(pathlock) printf("path error\n");
+  pathlock++;
+  }
+
+pathdata::pathdata(int i) { checklock(); }
+
+pathdata::pathdata(eMonster m, bool include_allies IS(true)) {
+  checklock();
+  if(isize(pathq))
+    println(hlog, "! we got tiles on pathq: ", isize(pathq));
+
+  computePathdist(m, include_allies);
+  }
+
+// pathdist end
+
+/** additional direction information for BFS algorithms.
+ *  It remembers from where we have got to this location
+ *  the opposite cell will be added to the queue first,
+ *  which helps the AI. Used in bfs().
+ **/
+EX vector<int> bfs_reachedfrom;
+
+/** calculate cpdist, 'have' flags, and do general fixings */
+EX void bfs() {
+
+  yendor::onpath();
+  
+  int dcs = isize(dcal);
+  for(int i=0; i<dcs; i++) dcal[i]->cpdist = INFD;
+  worms.clear(); ivies.clear(); ghosts.clear(); golems.clear(); 
+  tempmonsters.clear(); targets.clear(); 
+  statuecount = 0;
+  wetslime = 0;
+  hexsnakes.clear(); 
+
+  hadwhat = havewhat;
+  havewhat = 0; jiangshi_on_screen = 0;
+  snaketypes.clear();
+  if(!(hadwhat & HF_WARP)) { avengers = 0; }
+  if(!(hadwhat & HF_MIRROR)) { mirrorspirits = 0; }
+
+  elec::havecharge = false;
+  elec::afterOrb = false;
+  elec::haveelec = false;
+  airmap.clear();
+  if(!(hadwhat & HF_ROSE)) rosemap.clear();
+  
+  dcal.clear(); bfs_reachedfrom.clear();
+
+  for(cell *c: player_positions()) {
+    if(c->cpdist == 0) continue;
+    c->cpdist = 0;
+    dcal.push_back(c);
+    bfs_reachedfrom.push_back(hrand(c->type));
+    if(!invismove) targets.push_back(c);
+    }
+  
+  int distlimit = gamerange();
+
+  for(cell *c: player_positions()) {
+    if(items[itOrbDomination])
+    if(c->monst == moTentacle || c->monst == moTentaclewait || c->monst == moTentacleEscaping)
+      worms.push_back(c);
+    }
+  
+  int qb = 0;
+  first7 = 0;
+  while(true) {
+    if(qb == isize(dcal)) break;
+    int i, fd = bfs_reachedfrom[qb] + dcal[qb]->type/2;
+    cell *c = dcal[qb++];
+    
+    int d = c->cpdist;
+    
+    if(WDIM == 2 && d == distlimit) { first7 = qb; break; }
+
+    for(int j=0; j<c->type; j++) if(i = (fd+j) % c->type, c->move(i)) {
+      // printf("i=%d cd=%d\n", i, c->move(i)->cpdist);
+      cell *c2 = c->move(i);
+      if(!c2) continue;
+      
+      if(isWarpedType(c2->land)) havewhat |= HF_WARP;
+      if(c2->land == laMirror) havewhat |= HF_MIRROR;
+      
+      if((c->wall == waBoat || c->wall == waSea) &&
+        (c2->wall == waSulphur || c2->wall == waSulphurC))
+        c2->wall = waSea;
+      
+      if(c2 && signed(c2->cpdist) > d+1) {
+        if(WDIM == 3 && (d > 2 && !gmatrix.count(c2))) {
+          if(!first7) first7 = qb;
+          continue;
+          }
+        c2->cpdist = d+1;
+        
+        // remove treasures
+        if(!peace::on && c2->item && c2->cpdist == distlimit && itemclass(c2->item) == IC_TREASURE &&
+          !among(c2->item, itBrownian, itBabyTortoise) && WDIM != 3 &&
+          (items[c2->item] >= (ls::any_chaos()?10:20) + currentLocalTreasure || getGhostcount() >= 2)) {
+            c2->item = itNone;
+            if(c2->land == laMinefield) { c2->landparam &= ~3; }
+            }
+            
+        if(c2->item == itBombEgg && c2->cpdist == distlimit && items[itBombEgg] >= c2->landparam) {
+          c2->item = itNone;
+          c2->landparam |= 2;
+          c2->landparam &= ~1;
+          if(!c2->monst) c2->monst = moBomberbird, c2->stuntime = 0;
+          }
+        
+        if(c2->item == itBarrow && c2->cpdist == distlimit && c2->wall != waBarrowDig) {
+          c2->item = itNone;
+          }
+        
+        if(c2->item == itLotus && c2->cpdist == distlimit && items[itLotus] >= getHauntedDepth(c2)) {
+          c2->item = itNone;
+          }
+        
+        if(c2->item == itMutant2 && timerghost) {
+          bool rotten = true;
+          for(int i=0; i<c2->type; i++)
+            if(c2->move(i) && c2->move(i)->monst == moMutant)
+              rotten = false;
+          if(rotten) c2->item = itNone;
+          }
+        
+        if(c2->item == itDragon && (shmup::on ? shmup::curtime-c2->landparam>300000 : 
+          turncount-c2->landparam > 500))
+          c2->item = itNone;
+      
+        if(c2->item == itTrollEgg && c2->cpdist == distlimit && !shmup::on && c2->landparam && turncount-c2->landparam > 650)
+          c2->item = itNone;
+
+        if(c2->item == itWest && c2->cpdist == distlimit && items[itWest] >= c2->landparam + 4)
+          c2->item = itNone;
+      
+        if(c2->item == itMutant && c2->cpdist == distlimit && items[itMutant] >= c2->landparam) {
+          c2->item = itNone;
+          }
+      
+        if(c2->item == itIvory && c2->cpdist == distlimit && items[itIvory] >= c2->landparam) {
+          c2->item = itNone;
+          }
+        
+        if(c2->item == itAmethyst && c2->cpdist == distlimit && items[itAmethyst] >= -celldistAlt(c2)/5) {
+          c2->item = itNone;
+          }
+        
+        if(!keepLightning) c2->ligon = 0;
+        dcal.push_back(c2);
+        bfs_reachedfrom.push_back(c->c.spin(i));
+        
+        if(c2->wall == waBigStatue && c2->land != laTemple) 
+          statuecount++;
+        
+        if(isAlch(c2->wall) && c2->land == laWet)
+          wetslime++;
+          
+        if(cellHalfvine(c2) && isWarped(c2)) {
+          addMessage(XLAT("%The1 is destroyed!", c2->wall));
+          destroyHalfvine(c2);
+          }
+        
+        if(c2->wall == waCharged) elec::havecharge = true;
+        if(isElectricLand(c2)) elec::haveelec = true;
+        
+        if(c2->land == laWhirlpool) havewhat |= HF_WHIRLPOOL;
+        if(c2->land == laWhirlwind) havewhat |= HF_WHIRLWIND;
+        if(c2->land == laWestWall) havewhat |= HF_WESTWALL;
+        if(c2->land == laPrairie) havewhat |= HF_RIVER;
+        if(c2->land == laClearing) havewhat |= HF_MUTANT;
+
+        if(c2->wall == waRose) havewhat |= HF_ROSE;
+        
+        if((hadwhat & HF_ROSE) && (rosemap[c2] & 3)) havewhat |= HF_ROSE;
+        
+        if(c2->monst) {
+          if(isHaunted(c2->land) && 
+            c2->monst != moGhost && c2->monst != moZombie && c2->monst != moNecromancer)
+            fail_survivalist();
+          if(c2->monst == moHexSnake || c2->monst == moHexSnakeTail) {
+            havewhat |= HF_HEX;
+            if(c2->mondir != NODIR)
+              snaketypes.insert(snake_pair(c2));
+            if(c2->monst == moHexSnake) hexsnakes.push_back(c2);
+            else findWormIvy(c2);
+            }
+          else if(c2->monst == moKrakenT || c2->monst == moKrakenH) {
+            havewhat |= HF_KRAKEN;
+            }
+          else if(c2->monst == moDragonHead || c2->monst == moDragonTail) {
+            havewhat |= HF_DRAGON;
+            }
+          else if(c2->monst == moWitchSpeed) 
+            havewhat |= HF_FAST;
+          else if(c2->monst == moMutant)
+            havewhat |= HF_MUTANT;
+          else if(c2->monst == moJiangshi)
+            jiangshi_on_screen++;
+          else if(c2->monst == moOutlaw)
+            havewhat |= HF_OUTLAW;
+          else if(isGhostMover(c2->monst))
+            ghosts.push_back(c2);
+          else if(isWorm(c2) || isIvy(c2)) findWormIvy(c2);
+          else if(isBug(c2)) {
+            havewhat |= HF_BUG;
+            targets.push_back(c2);
+            }
+          else if(isFriendly(c2)) {
+            if(c2->monst != moMouse && !markEmpathy(itOrbInvis) && !(isWatery(c2) && markEmpathy(itOrbFish)) &&
+              !c2->stuntime) targets.push_back(c2);
+            if(c2->monst == moGolem) golems.push_back(c2);
+            if(c2->monst == moFriendlyGhost) golems.push_back(c2);
+            if(c2->monst == moKnight) golems.push_back(c2);
+            if(c2->monst == moTameBomberbird) golems.push_back(c2);
+            if(c2->monst == moMouse) { golems.push_back(c2); havewhat |= HF_MOUSE; }
+            if(c2->monst == moPrincess || c2->monst == moPrincessArmed) golems.push_back(c2);
+            if(c2->monst == moIllusion) {
+              if(items[itOrbIllusion]) items[itOrbIllusion]--;
+              else c2->monst = moNone;
+              }
+            }
+          else if(c2->monst == moButterfly) {
+            addButterfly(c2);
+            }
+          else if(isAngryBird(c2->monst)) {
+            havewhat |= HF_BIRD;
+            if(c2->monst == moBat) havewhat |= HF_BATS | HF_EAGLES;
+            if(c2->monst == moEagle) havewhat |= HF_EAGLES;
+            }
+          else if(among(c2->monst, moFrog, moVaulter, moPhaser))
+            havewhat |= HF_JUMP;
+          else if(c2->monst == moReptile) havewhat |= HF_REPTILE;
+          else if(isLeader(c2->monst)) havewhat |= HF_LEADER;
+          else if(c2->monst == moEarthElemental) havewhat |= HF_EARTH;
+          else if(c2->monst == moWaterElemental) havewhat |= HF_WATER;
+          else if(c2->monst == moVoidBeast) havewhat |= HF_VOID;
+          else if(c2->monst == moHunterDog) havewhat |= HF_HUNTER;
+          else if(isMagneticPole(c2->monst)) havewhat |= HF_MAGNET;
+          else if(c2->monst == moAltDemon) havewhat |= HF_ALT;
+          else if(c2->monst == moHexDemon) havewhat |= HF_HEXD;
+          else if(among(c2->monst, moAnimatedDie, moAngryDie)) havewhat |= HF_DICE;
+          else if(c2->monst == moMonk) havewhat |= HF_MONK;
+          else if(c2->monst == moShark || c2->monst == moCShark || among(c2->monst, moRusalka, moPike)) havewhat |= HF_SHARK;
+          else if(c2->monst == moAirElemental) 
+            havewhat |= HF_AIR, airmap.push_back(make_pair(c2,0));
+          }
+        // pheromones!
+        if(c2->land == laHive && c2->landparam >= 50 && c2->wall != waWaxWall) 
+          havewhat |= HF_BUG;
+        if(c2->wall == waThumperOn)
+          targets.push_back(c2);
+
+        }
+      }
+    }
+
+  for(int i=first7; i<isize(dcal); i++)
+    forCellEx(c2, dcal[i])
+      if(c2->wall == waThumperOn) {
+        targets.push_back(c2);
+        }
+  
+  for(auto& t: tempmonsters) t.first->monst = t.second;
+  
+  buildAirmap();
+  }
+
+EX void moverefresh(bool turn IS(true)) {
+  int dcs = isize(dcal);
+  
+  for(int i=0; i<dcs; i++) {
+    cell *c = dcal[i];
+    
+    if(c->monst == moWolfMoved) c->monst = moWolf;
+    if(c->monst == moIvyNext) {
+      c->monst = moIvyHead; ivynext(c);
+      }
+    if(c->monst == moIvyDead) 
+      removeIvy(c);
+    refreshFriend(c);
+    if(c->monst == moSlimeNextTurn) c->monst = moSlime;
+    if(c->monst == moLesser && !cellEdgeUnstable(c)) c->monst = moLesserM;
+    else if(c->monst == moLesserM) c->monst = moLesser;
+    if(c->monst == moGreater && !cellEdgeUnstable(c)) c->monst = moGreaterM;
+    else if(c->monst == moGreaterM) c->monst = moGreater;
+    
+    if(c->monst == moPair && !c->stuntime) {
+      cell *c2 = c->move(c->mondir);
+      if(c2->monst != moPair) continue;
+      if(true) for(int i: {-1, 1}) {
+        cell *c3 = c->modmove(c->mondir + i);
+        if(among(c3->wall, waRuinWall, waColumn, waStone, waVinePlant, waPalace)) {
+          drawParticles(c3, winf[c3->wall].color, 30);
+          c3->wall = waNone;
+          }
+        }
+      }
+    
+    if(c->stuntime && !isMutantIvy(c)) {
+      if(turn) c->stuntime--;
+      int breathrange = sphere ? 2 : 3;
+      if(c->stuntime == 0 && c->monst == moDragonHead)  {
+        // if moDragonHead is renamed to "Dragon Head", we might need to change this
+        eMonster subject = c->monst;
+        if(!c->hitpoints) c->hitpoints = 1;
+        else if(shmup::on && dragon::totalhp(c) > 2 && shmup::dragonbreath(c)) {
+          c->hitpoints = 0;
+          }
+        else if(dragon::totalhp(c) <= 2) ;
+        else if(isMounted(c)) {
+          if(dragon::target && celldistance(c, dragon::target) <= breathrange && makeflame(dragon::target, 5, true)) {
+            addMessage(XLAT("%The1 breathes fire!", subject));
+            makeflame(dragon::target, 5, false);
+            playSound(dragon::target, "fire");
+            c->hitpoints = 0;
+            }
+          }
+        else {
+          for(int i=0; i<isize(targets); i++) {
+            cell *t = targets[i];
+            if(celldistance(c, t) <= breathrange && makeflame(t, 5, true)) {
+              if(isPlayerOn(t)) addMessage(XLAT("%The1 breathes fire at you!", subject));
+              else if(t->monst)
+                addMessage(XLAT("%The1 breathes fire at %the2!", subject, t->monst));
+              else
+                addMessage(XLAT("%The1 breathes fire!", subject));
+              makeflame(t, 5, false);
+              playSound(t, "fire");
+              c->hitpoints = 0;
+              }
+            }
+          }
+        }
+      }
+    
+    // tortoises who have found their children no longer move
+    if(saved_tortoise_on(c))
+      c->stuntime = 2;
+    
+    if(c->monst == moReptile) {
+      if(c->wall == waChasm || cellUnstable(c)) {
+        c->monst = moNone;
+        c->wall = waReptile;
+        c->wparam = reptilemax();
+        playSound(c, "click");
+        }
+      else if(isChasmy(c) || isWatery(c)) {
+        if(c->wall == waMercury) {
+          fallMonster(c, AF_FALL);
+          c->wall = waNone;
+          }
+        else {
+          c->wall = waReptileBridge;
+          c->wparam = reptilemax();
+          c->monst = moNone;
+          }
+        c->item = itNone;
+        playSound(c, "click");
+        }
+      }
+        
+    if(c->wall == waChasm) {
+      if(c->land != laWhirlwind) c->item = itNone;
+      
+      if(c->monst && !survivesChasm(c->monst) && c->monst != moReptile && normal_gravity_at(c)) {
+        if(c->monst != moRunDog && c->land == laMotion) 
+          achievement_gain_once("FALLDEATH1");
+        addMessage(XLAT("%The1 falls!", c->monst));
+        fallMonster(c, AF_FALL);
+        }
+      }
+    
+    else if(isReptile(c->wall) && turn) {
+      if(c->monst || isPlayerOn(c)) c->wparam = -1;
+      else if(c->cpdist <= 7) {
+        c->wparam--;
+        if(c->wparam == 0) {
+          if(c->wall == waReptile) c->wall = waChasm;
+          else placeWater(c, NULL);
+          c->monst = moReptile;
+          c->hitpoints = 3;
+          c->stuntime = 0;
+          vector<int> gooddirs;
+          // in the peace mode, a reptile will
+          // prefer to walk on the ground, rather than the chasm
+          for(int i=0; i<c->type; i++) {
+            int i0 = (i+3) % c->type;
+            int i1 = (i+c->type-3) % c->type;
+            if(c->move(i0) && passable(c->move(i0), c, 0)) 
+            if(c->move(i1) && passable(c->move(i1), c, 0)) 
+              gooddirs.push_back(i);
+            }
+          c->mondir = hrand_elt(gooddirs, c->mondir);
+          playSound(c, "click");
+          }
+        }
+      }
+
+    else if(isFire(c)) {
+      if(c->monst == moSalamander) c->stuntime = max<int>(c->stuntime, 1);
+      else if(c->monst == moVaulter && c->mondir == JUMP)
+        c->mondir = NODIR;
+      else if(c->monst && !survivesFire(c->monst) && !isWorm(c->monst)) {
+        addMessage(XLAT("%The1 burns!", c->monst));
+        if(isBull(c->monst)) {
+          addMessage(XLAT("Fire is extinguished!"));
+          c->wall = waNone;
+          }
+        fallMonster(c, AF_CRUSH);
+        }
+      if(c->item && itemBurns(c->item)) {
+        addMessage(XLAT("%The1 burns!", c->item));
+        c->item = itNone;
+        }
+      }
+    
+    else if(isWatery(c)) {
+      if(c->monst == moLesser || c->monst == moLesserM || c->monst == moGreater || c->monst == moGreaterM)
+        c->monst = moGreaterShark;
+      if(c->monst && !survivesWater(c->monst) && normal_gravity_at(c)) {
+        playSound(c, "splash"+pick12());
+        if(isNonliving(c->monst))
+          addMessage(XLAT("%The1 sinks!", c->monst));
+        else 
+          addMessage(XLAT("%The1 drowns!", c->monst));
+        if(isBull(c->monst)) {
+          addMessage(XLAT("%The1 is filled!", c->wall));
+          c->wall = waShallow;
+          }
+        fallMonster(c, AF_FALL);
+        }
+      }
+    else if(c->wall == waSulphur || c->wall == waSulphurC || c->wall == waMercury) {
+      if(c->monst && !survivesPoison(c->monst, c->wall) && normal_gravity_at(c)) {
+        playSound(c, "splash"+pick12());
+        if(isNonliving(c->monst))
+          addMessage(XLAT("%The1 sinks!", c->monst));
+        else 
+          addMessage(XLAT("%The1 drowns!", c->monst));
+        if(isBull(c->monst)) {
+          addMessage(XLAT("%The1 is filled!", c->wall));
+          c->wall = waNone;
+          }
+        fallMonster(c, AF_FALL);
+        }
+      }
+    else if(c->wall == waMagma) {
+      if(c->monst == moSalamander) c->stuntime = max<int>(c->stuntime, 1);
+      else if(c->monst && !survivesPoison(c->monst, c->wall) && normal_gravity_at(c)) {
+        if(isNonliving(c->monst))
+          addMessage(XLAT("%The1 is destroyed by lava!", c->monst));
+        else 
+          addMessage(XLAT("%The1 is killed by lava!", c->monst));
+        playSound(c, "steamhiss", 70);
+        fallMonster(c, AF_FALL);
+        }
+      }
+    else if(!isWateryOrBoat(c) && c->wall != waShallow) {
+      if(c->monst == moGreaterShark)
+        c->monst = moGreaterM;
+      else if(c->monst == moShark || c->monst == moCShark) {
+        addMessage(XLAT("%The1 suffocates!", c->monst));
+        fallMonster(c, AF_CRUSH);
+        }
+      else if(c->monst == moKrakenH) {
+        addMessage(XLAT("%The1 suffocates!", c->monst));
+        kraken::kill(c, moNone);
+        }
+      }
+    
+    if(c->monst == moVineSpirit && !cellHalfvine(c) && c->wall != waVinePlant) {
+      addMessage(XLAT("%The1 is destroyed!", c->monst));
+      fallMonster(c, AF_CRUSH);
+      }
+    
+    if(c->monst) mayExplodeMine(c, c->monst);
+    
+    if(c->monst && c->wall == waClosedGate && !survivesWall(c->monst)) {
+      playSound(c, "hit-crush"+pick123());
+      addMessage(XLAT("%The1 is crushed!", c->monst));
+      fallMonster(c, AF_CRUSH);
+      }
+
+    if(c->monst && cellUnstable(c) && !ignoresPlates(c->monst) && !shmup::on) 
+      doesFallSound(c);
+    }
+  }
+
+// find worms and ivies
+EX void settemp(cell *c) {
+  tempmonsters.emplace_back(c, (eMonster) c->monst);
+  c->monst = moNone;
+  }
+
+EX void findWormIvy(cell *c) {
+  while(true) {
+    if(c->monst == moWorm || c->monst == moTentacle || c->monst == moWormwait || c->monst == moTentaclewait ||
+      c->monst == moTentacleEscaping) {
+      worms.push_back(c); settemp(c);
+      break;
+      }
+    else if(c->monst == moHexSnake) {
+      hexsnakes.push_back(c); settemp(c);
+      }
+    else if(c->monst == moWormtail || c->monst == moHexSnakeTail) {
+      bool bug = true;
+      for(int i=0; i<c->type; i++) {
+        cell* c2 = c->move(i);
+        if(c2 && isWorm(c2) && c2->mondir != NODIR && c2->move(c2->mondir) == c) {
+          settemp(c);
+          c = c2;
+          bug = false;
+          }
+        }
+      if(bug) break;
+      }
+    else if(c->monst == moIvyWait) {
+      cell* c2 = c->move(c->mondir);
+      settemp(c); c=c2;
+      }
+    else if(c->monst == moIvyHead) {
+      ivies.push_back(c); settemp(c);
+      break;
+      }
+    else if(c->monst == moIvyBranch || c->monst == moIvyRoot) {
+      bool bug = true;
+      for(int i=0; i<c->type; i++) {
+        cell* c2 = c->move(i);
+        if(c2 && (c2->monst == moIvyHead || c2->monst == moIvyBranch) && c2->move(c2->mondir) == c) {
+          settemp(c);
+          c = c2;
+          bug = false;
+          }
+        }
+      if(bug) break;
+      }
+    else break;
+    }
+  }
+
+EX void advance_tides() {
+  calcTidalPhase();
+  recalcTide = true;
+  while(recalcTide) {
+    recalcTide = false;
+    for(int i=0; i<isize(dcal); i++) checkTide(dcal[i]);
+    }
+  }
+
+EX void monstersTurn() {
+  reset_spill();
+  checkSwitch();
+  mirror::breakAll();
+  DEBB(DF_TURN, ("bfs"));
+  bfs();
+  DEBB(DF_TURN, ("charge"));
+  if(elec::havecharge) elec::act();
+  DEBB(DF_TURN, ("mmo"));
+  int phase2 = (1 & items[itOrbSpeed]);
+  if(!phase2) movemonsters();
+
+  for(cell *pc: player_positions()) if(pc->item == itOrbSafety)  {
+    collectItem(pc, pc, true);
+    return;
+    }
+
+  if(playerInPower() && (phase2 || !items[itOrbSpeed]) && (havewhat & HF_FAST)) 
+    moveNormals(moWitchSpeed);
+
+  if(phase2 && markOrb(itOrbEmpathy)) {
+    bfs();
+    movegolems(AF_FAST);
+    for(int i=0; i<isize(dcal); i++) {
+      if(dcal[i]->monst == moFriendlyGhost && dcal[i]->stuntime)
+        dcal[i]->stuntime--;
+      refreshFriend(dcal[i]);
+      }
+    }
+  DEBB(DF_TURN, ("rop"));
+  if(!dual::state) reduceOrbPowers();
+  int phase1 = (1 & items[itOrbSpeed]);
+  if(dual::state && items[itOrbSpeed]) phase1 = !phase1;
+  DEBB(DF_TURN, ("lc"));
+  if(!phase1) livecaves();
+  if(!phase1) ca::simulate();
+  if(!phase1) heat::processfires();
+  // this depends on turncount, so we do it always
+  advance_tides();
+  
+  for(cell *c: crush_now) {
+    changes.ccell(c);
+    playSound(NULL, "closegate");
+    if(canAttack(c, moCrusher, c, c->monst, AF_GETPLAYER | AF_CRUSH)) {
+      attackMonster(c, AF_MSG | AF_GETPLAYER | AF_CRUSH, moCrusher);
+      }
+    moveEffect(movei(c, FALL), moDeadBird);
+    destroyBoats(c, NULL, true);
+    explodeBarrel(c);
+    }
+  
+  changes.value_keep(crush_now);
+  changes.value_keep(crush_next);
+  crush_now = std::move(crush_next);
+  crush_next.clear();
+  
+  DEBB(DF_TURN, ("heat"));
+  heat::processheat();
+  // if(elec::havecharge) elec::drawcharges();
+
+  orbbull::check();
+
+  #if CAP_COMPLEX2
+  if(!phase1) terracotta::check();
+  #endif
+  
+  if(items[itOrbFreedom])
+    for(cell *pc: player_positions())
+      checkFreedom(pc);
+
+  DEBB(DF_TURN, ("check"));
+  checkmove();
+  if(canmove) elec::checklightningfast();
+
+
+#if CAP_HISTORY
+  for(cell *pc: player_positions())
+    history::movehistory.push_back(pc);
+#endif
+  }
+
+/** check if whirlline is looped, if yes, remove the repeat; may not detect loops immediately */
+EX bool looped(vector<cell*>& whirlline) {
+  if(isize(whirlline) == 1)
+    return false;
+  if(whirlline.back() == whirlline.front()) {
+    whirlline.pop_back();
+    return true;
+    }
+  int pos = isize(whirlline)/2;
+  if(isize(whirlline) > 2 && whirlline.back() == whirlline[pos]) {
+    while(pos && whirlline.back() == whirlline[pos])
+      whirlline.pop_back();
+    /* something weird must have happened... */
+    static bool once = true;
+    if(once) addMessage("warning: a looped line");
+    once = false;
+    return true;
+    }
+  return false;
+  }
+
+}

fake-mobile.cpp

@@ -1,19 +1,22 @@
 // Hyperbolic Rogue -- fake mobile target
 // Copyright (C) 2011-2018 Zeno Rogue, see 'hyper.cpp' for details
+//
+// Compile with: g++ fake-mobile.cpp -o fake-mobile -I/usr/include/SDL -lSDL -lSDL_gfx -lGL -lSDL_ttf -lz -Wno-invalid-offsetof
 
 #define ISFAKEMOBILE 1
 #define MOBPAR_FORMAL int
 #define MOBPAR_ACTUAL 0
 #define MIX_MAX_VOLUME 128
+#define NOMAIN
 #include <string>
 
 namespace hr {
-  const char *scorefile = "fakemobile_score.txt";  
+  std::string scorefile = "fakemobile_score.txt";
   }
 
 #include <SDL/SDL.h>
 
-#include "init.cpp"
+#include "hyper.cpp"
 
 #include <SDL/SDL_ttf.h>
 #include <SDL/SDL_gfxPrimitives.h>
@@ -32,14 +35,16 @@ transmatrix getOrientation() {
   lasttick = curtick;
   Uint8 *keystate = SDL_GetKeyState(NULL);
   if(keystate[SDLK_LCTRL]) {
-    if(keystate['s']) Orient = Orient * rotmatrix(t, 2, 1);
-    if(keystate['w']) Orient = Orient * rotmatrix(t, 1, 2);
-    if(keystate['a']) Orient = Orient * rotmatrix(t, 2, 0);
-    if(keystate['d']) Orient = Orient * rotmatrix(t, 0, 2);
+    if(keystate['s']) Orient = Orient * cspin(2, 1, t);
+    if(keystate['w']) Orient = Orient * cspin(1, 2, t);
+    if(keystate['a']) Orient = Orient * cspin(2, 0, t);
+    if(keystate['d']) Orient = Orient * cspin(0, 2, t);
     }
   return Orient;
   }
 
+void resetmusic() { printf("resetmusic\n"); }
+
 void playSound(cell *c, const string& fname, int vol) {
   printf("Play sound: %s\n", fname.c_str());
   }
@@ -52,6 +57,17 @@ int gdpop() { return graphdata[gdpos++]; }
 
 TTF_Font *font[256];
 
+const char* fontname = "DejaVuSans-Bold.ttf";
+
+void load_font() {
+  if(!font[size])
+    font[size] = TTF_OpenFont(fontname, size);
+  if(!font[size]) {
+    fprintf(stderr, "failed to open font: %s", fontname);
+    exit(1);
+    }
+  }
+
 bool rawdisplaystr(int x, int y, int shift, int size, const char *str, int color, int align) {
 
   if(strlen(str) == 0) return false;
@@ -66,8 +82,7 @@ bool rawdisplaystr(int x, int y, int shift, int size, const char *str, int color
   
   col.r >>= darken; col.g >>= darken; col.b >>= darken;
 
-  if(!font[size])
-    font[size] = TTF_OpenFont("VeraBd.ttf", size);
+  load_font();
 
   SDL_Surface *txt = TTF_RenderText_Solid(font[size], str, col);
   
@@ -92,7 +107,7 @@ bool rawdisplaystr(int x, int y, int shift, int size, const char *str, int color
 int textwidth(int siz, const string &str) {
   if(isize(str) == 0) return 0;
   
-  if(!font[siz]) font[siz] = TTF_OpenFont("VeraBd.ttf", siz);
+  load_font();
   
   int w, h;
   TTF_SizeUTF8(font[siz], str.c_str(), &w, &h);
@@ -123,6 +138,7 @@ using namespace hr;
 int main(int argc, char **argv) {
 
   initAll();
+  glhr::init();
   
   vid.xres = 800; vid.yres = 450;
   vid.usingGL = false;
@@ -200,11 +216,17 @@ int main(int argc, char **argv) {
 
         case 4: {
           int col = gdpop();
+          int out = gdpop();
           int x = gdpop(), y = gdpop(), rad = gdpop();
           
           aacircleColor(s, x, y, rad, (col << 8) + 0xFF);
           }
 
+        case 5: {
+          int out = gdpop();
+          /* not implemented */
+          }
+
         }
       }
     SDL_UpdateRect(s, 0, 0, vid.xres, vid.yres);

fake.cpp

@@ -0,0 +1,799 @@
+#include "hyper.h"
+
+// Fake non-Euclidean
+
+namespace hr {
+
+EX namespace fake {
+
+  EX ld scale;
+  
+  EX bool multiple;
+  
+  EX bool multiple_special_draw = true;
+  EX bool recursive_draw = false;
+  
+  EX eGeometry underlying;
+  EX geometry_information *underlying_cgip;
+  EX hrmap *pmap;
+  EX geometry_information *pcgip;
+  EX eGeometry actual_geometry;
+
+  EX int ordered_mode = 0;
+  
+  EX bool in() { return geometry == gFake; }
+
+  EX void on_dim_change() { pmap->on_dim_change(); }
+  
+  /** like in() but takes slided arb into account */
+  EX bool split() { return in() || arb::in_slided(); }
+  
+  EX bool available() {
+    if(in()) return true;
+    if(WDIM == 2 && standard_tiling() && (PURE || BITRUNCATED)) return true;
+    if(arcm::in() && PURE) return true;
+    if(hat::in()) return true;
+    if(WDIM == 2) return false;
+    if(among(geometry, gBitrunc3)) return false;
+    #if MAXMDIM >= 4
+    if(reg3::in() && !among(variation, eVariation::pure, eVariation::subcubes, eVariation::coxeter, eVariation::bch_oct)) return false;
+    return euc::in() || reg3::in();
+    #else
+    return euc::in();
+    #endif
+    }
+  
+  map<cell*, ld> random_order;
+
+  // a dummy map that does nothing
+  struct hrmap_fake : hrmap {
+    hrmap *underlying_map;
+    
+    template<class T> auto in_underlying(const T& t) -> decltype(t()) {
+      pcgip = cgip; 
+      dynamicval<hrmap*> gpm(pmap, this);
+      dynamicval<eGeometry> gag(actual_geometry, geometry);
+      dynamicval<eGeometry> g(geometry, underlying);
+      dynamicval<int> uc(cgip->use_count, cgip->use_count+1);
+      dynamicval<geometry_information*> gc(cgip, underlying_cgip);
+      dynamicval<hrmap*> gu(currentmap, underlying_map);
+      return t();
+      }
+
+    heptagon *getOrigin() override { return in_underlying([this] { return underlying_map->getOrigin(); }); }
+    
+    cell* gamestart() override { return in_underlying([this] { return underlying_map->gamestart(); }); }
+
+    hrmap_fake(hrmap *u) {
+      underlying_map = u;
+      for(hrmap*& m: allmaps) if(m == underlying_map) m = this;
+      if(currentmap == u) currentmap = this;
+      }
+
+    void find_cell_connection(cell *c, int d) override { 
+      FPIU(createMov(c, d));
+      }
+  
+    hrmap_fake() {
+      underlying_map = nullptr;
+      in_underlying([this] { initcells(); underlying_map = currentmap; });
+      for(hrmap*& m: allmaps) if(m == underlying_map) m = NULL;
+      }
+    
+    ~hrmap_fake() { 
+      in_underlying([this] {
+        delete underlying_map; 
+        });
+      }
+    
+    heptagon *create_step(heptagon *parent, int d) override {
+      return FPIU(currentmap->create_step(parent, d));
+      }
+
+    hyperpoint get_corner(cell *c, int cid, ld cf=3) override { 
+
+      if(embedded_plane) {
+        geom3::light_flip(true);
+        hyperpoint h = get_corner(c, cid, cf);
+        geom3::light_flip(false);
+        return cgi.emb->base_to_actual(h);
+        }
+
+      if(arcm::in() || hat::in()) {
+        return underlying_map->get_corner(c, cid, cf);
+        }
+
+      hyperpoint h;
+      h = FPIU(currentmap->get_corner(c, cid, cf));
+      return befake(h);
+      }
+
+    transmatrix adj(cell *c, int d) override {
+      if(embedded_plane) {
+        geom3::light_flip(true);
+        transmatrix T = adj(c, d);
+        geom3::light_flip(false);
+        return cgi.emb->base_to_actual(T);
+        }
+      if(hat::in()) return underlying_map->adj(c, d);
+      if(variation == eVariation::coxeter) {
+        array<int, 3> which;
+        in_underlying([&which, c, d] {
+          auto T = currentmap->adj(c, d);
+          auto& f1 = currentmap->get_cellshape(c).faces_local[d];
+          auto& f2 = currentmap->get_cellshape(c->move(d)).faces_local[c->c.spin(d)];
+          for(int i=0; i<3; i++) {
+            which[i] = -1;
+            for(int j=0; j<isize(f2); j++)
+              if(hdist(T * f2[j], f1[i]) < 1e-6)
+                which[i] = j;
+            }
+          });
+        auto& f1 = get_cellshape(c).faces_local[d];
+        auto& f2 = get_cellshape(c->move(d)).faces_local[c->c.spin(d)];
+        vector<ld> d1;
+        for(auto& v: f1) d1.push_back(hdist0(normalize(v)));
+        vector<hyperpoint> cf2(3);
+        for(int i=0; i<3; i++)
+          cf2[i] = f2[which[i]];
+        transmatrix F2, F1;
+        for(int i=0; i<3; i++) set_column(F2, i, cf2[i]);
+        for(int i=0; i<3; i++) set_column(F1, i, f1[i]);
+
+        auto dtang = [] (vector<hyperpoint> v) {
+          if(euclid) return (v[1] - v[0]) ^ (v[2] - v[0]);
+          transmatrix T = gpushxto0(normalize(v[0]));
+          hyperpoint h = iso_inverse(T) * ((T*v[1]) ^ (T*v[2]));
+          return h;
+          };
+
+        set_column(F2, 3, dtang(cf2));
+        set_column(F1, 3, dtang(f1));
+        transmatrix T = F1 * inverse(F2);
+        return T;
+        }
+      transmatrix S1, S2;
+      ld dist;
+      #if MAXMDIM >= 4
+      bool impure = reg3::in() && !PURE;
+      #else
+      bool impure = !PURE;
+      #endif
+      vector<int> mseq;
+      if(impure) {
+        mseq = FPIU ( currentmap->get_move_seq(c, d) );
+        if(mseq.empty()) {
+          auto& s1 = get_cellshape(c);
+          auto& s2 = get_cellshape(c->move(d));
+          return s1.from_cellcenter * s2.to_cellcenter;
+          }
+        if(isize(mseq) > 1)
+          throw hr_exception("fake adj not implemented for isize(mseq) > 1");
+        }
+      in_underlying([c, d, &S1, &S2, &dist, &impure, &mseq] {
+        #if CAP_ARCM
+        dynamicval<bool> u(arcm::use_gmatrix, false);
+        #endif
+        transmatrix T;
+        if(impure) {
+          T = currentmap->adj(c->master, mseq[0]);
+          }
+        else {
+          T = currentmap->adj(c, d);
+          }
+        S1 = rspintox(tC0(T));
+        transmatrix T1 = spintox(tC0(T)) * T;
+        dist = hdist0(tC0(T1));
+        S2 = xpush(-dist) * T1;
+        });
+      
+      if(impure) {
+        auto& s1 = get_cellshape(c);
+        auto& s2 = get_cellshape(c->move(d));
+        S1 = s1.from_cellcenter * S1;
+        S2 = S2 * s2.to_cellcenter;
+        }
+
+      #if CAP_ARCM
+      if(arcm::in()) {
+        int t = arcm::id_of(c->master);
+        int t2 = arcm::id_of(c->move(d)->master);
+        auto& cof = arcm::current_or_fake();
+        cgi.adjcheck = cof.inradius[t/2] + cof.inradius[t2/2];
+        }
+      #else
+      if(0) ;
+      #endif
+      
+      else if(WDIM == 2) {
+      
+        ld dist;
+        in_underlying([c, d, &dist] {
+          dist = currentmap->spacedist(c, d);
+          });
+        
+        auto& u = *underlying_cgip;
+        if(dist == u.tessf) cgi.adjcheck = cgi.tessf;
+        else if(dist == u.crossf) cgi.adjcheck = cgi.crossf;
+        else if(dist == u.hexhexdist) cgi.adjcheck = cgi.hexhexdist;
+        else cgi.adjcheck = dist * scale;        
+        }
+      
+      else if(underlying == gBitrunc3) {
+        ld x = (d % 7 < 3) ? 1 : sqrt(3)/2;
+        x *= scale;
+        cgi.adjcheck = 2 * atanh(x);
+        }
+      
+      return S1 * xpush(cgi.adjcheck) * S2;
+      }
+    
+    void draw_recursive(cell *c, const shiftmatrix& V, ld a0, ld a1, cell *parent, int depth) {
+      if(!do_draw(c, V)) return;
+      drawcell(c, V);
+      
+      if(depth >= 15) return;
+      
+      // queuestr(V, .2, fts(a0)+":"+fts(a1), 0xFFFFFFFF, 1);
+      
+      ld d = hdist0(tC0(V));
+
+      if(false) {
+        curvepoint(spin(-a0) * xpush0(d));
+        curvepoint(spin(-a0) * xpush0(d+.2));
+        curvepoint(spin(-a1) * xpush0(d+.2));
+        curvepoint(spin(-a1) * xpush0(d));
+        curvepoint(spin(-a0) * xpush0(d));
+        queuecurve(shiftless(Id), 0xFF0000FF, 0, PPR::LINE);
+        }
+
+
+      indenter id(2);
+      for(int i=0; i<c->type; i++) if(c->move(i) && c->move(i) != parent) {
+        auto h0 = V * befake(FPIU(get_corner_position(c, i)));
+        auto h1 = V * befake(FPIU(get_corner_position(c, (i+1) % c->type)));
+        ld b0 = atan2(unshift(h0));
+        ld b1 = atan2(unshift(h1));
+        while(b1 < b0) b1 += TAU;
+        if(a0 == -1) {
+          draw_recursive(c->move(i), optimized_shift(V * adj(c, i)), b0, b1, c, depth+1);
+          }
+        else {
+          if(b1 - b0 > M_PI) continue;
+          
+          cyclefix(b0, a0);
+          if(b0 < a0) b0 = a0;
+          
+          cyclefix(b1, a1);
+          if(b1 > a1) b1 = a1;
+          
+          if(b0 > b1) continue;
+          
+          draw_recursive(c->move(i), optimized_shift(V * adj(c, i)), b0, b1, c, depth+1);
+          }
+        }
+      }
+
+    transmatrix relative_matrixc(cell *h2, cell *h1, const hyperpoint& hint) override {
+      if(arcm::in()) return underlying_map->relative_matrix(h2, h1, hint);
+      if(h1 == h2) return Id;
+  
+      for(int a=0; a<h1->type; a++) if(h1->move(a) == h2)
+        return adj(h1, a);
+
+      return Id;
+      }
+
+    transmatrix relative_matrixh(heptagon *h2, heptagon *h1, const hyperpoint& hint) override {
+      if(arcm::in()) return underlying_map->relative_matrix(h2, h1, hint);
+      return relative_matrix(h2->c7, h1->c7, hint);
+      }
+
+    void draw_at(cell *at, const shiftmatrix& where) override {
+      sphereflip = Id;
+      
+      // for(int i=0; i<S6; i++) queuepoly(ggmatrix(cwt.at), shWall3D[i], 0xFF0000FF);
+      
+      if(pmodel == mdDisk && WDIM == 2 && recursive_draw) {
+        draw_recursive(at, where, -1, -1, nullptr, 0);
+        return;
+        }
+      
+      dq::clear_all();
+      
+      int id = 0;
+      int limit = 100 * pow(1.2, sightrange_bonus);
+      if(WDIM == 3 || vid.use_smart_range) 
+        limit = INT_MAX;
+        
+      if(ordered_mode && !(multiple && multiple_special_draw)) {
+        using pct = pair<cell*, shiftmatrix>;
+        auto comparer = [] (pct& a1, pct& a2) { 
+          if(ordered_mode > 2) {
+            auto val = [] (pct& a) {
+              if(!random_order.count(a.first))
+                random_order[a.first] = randd() * 2;
+              return random_order[a.first] + hdist0(tC0(a.second));
+              };
+            return val(a1) > val(a2);
+            }
+          return a1.second[LDIM][LDIM] > a2.second[LDIM][LDIM]; 
+          };
+        std::priority_queue<pct, std::vector<pct>, decltype(comparer)> myqueue(comparer);
+        
+        auto enq = [&] (cell *c, const shiftmatrix& V) {
+          if(!c) return;
+          if(ordered_mode == 1 || ordered_mode == 3) {
+            if(dq::visited_c.count(c)) return;
+            dq::visited_c.insert(c);
+            }
+          myqueue.emplace(c, V);          
+          };
+
+        enq(centerover, cview());
+
+        while(!myqueue.empty()) {
+          auto& p = myqueue.top();
+          id++;
+          cell *c = p.first;
+          shiftmatrix V = p.second;
+          myqueue.pop();
+          
+          if(ordered_mode == 2 || ordered_mode == 4) {
+            if(dq::visited_c.count(c)) continue;
+            dq::visited_c.insert(c);
+            }
+
+          if(!do_draw(c, V)) continue;
+          drawcell(c, V);
+
+          if(in_wallopt() && isWall3(c) && isize(dq::drawqueue_c) > 1000) continue;
+
+          if(id > limit) continue;
+    
+          for(int i=0; i<c->type; i++) if(c->move(i)) {
+            enq(c->move(i), optimized_shift(V * adj(c, i)));
+            }
+          }
+        
+        return;
+        }
+
+      auto enqueue = (multiple && multiple_special_draw ? dq::enqueue_by_matrix_c : dq::enqueue_c);
+      enqueue(at, where);
+      
+      while(!dq::drawqueue_c.empty()) {
+        auto& p = dq::drawqueue_c.front();
+        id++;
+        cell *c = p.first;
+        shiftmatrix V = p.second;
+        dq::drawqueue_c.pop();
+
+        if(!do_draw(c, V)) continue;
+        drawcell(c, V);
+        if(in_wallopt() && isWall3(c) && isize(dq::drawqueue_c) > 1000) continue;
+        
+        if(id > limit) continue;
+    
+        for(int i=0; i<c->type; i++) if(c->move(i)) {
+          enqueue(c->move(i), optimized_shift(V * adj(c, i)));
+          }
+        }
+      }
+
+    ld spin_angle(cell *c, int d) override {
+      return underlying_map->spin_angle(c,d);
+      }
+
+    int shvid(cell *c) override {
+      return FPIU( currentmap->shvid(c) );
+      }
+
+    subcellshape& get_cellshape(cell *c) override {
+      return *FPIU( (cgip = pcgip, &(currentmap->get_cellshape(c))) );
+      }
+
+    transmatrix ray_iadj(cell *c, int i) override {
+      if(WDIM == 2)
+        return to_other_side(get_corner(c, i), get_corner(c, i+1));
+      #if MAXMDIM >= 4
+      if(PURE) return iadj(c, i);      
+      auto& v = get_cellshape(c).faces_local[i];
+      hyperpoint h = 
+        project_on_triangle(v[0], v[1], v[2]);
+      transmatrix T = rspintox(h);
+      return T * xpush(-2*hdist0(h)) * spintox(h);
+      #else
+      return Id;
+      #endif
+      }
+    };
+  
+  EX hrmap* new_map() { return new hrmap_fake; }
+
+  EX hrmap* get_umap() { if(!dynamic_cast<hrmap_fake*>(currentmap)) return nullptr; else return ((hrmap_fake*)currentmap)->underlying_map; }
+
+  #if HDR
+  template<class T> auto in_underlying_geometry(const T& f) -> decltype(f()) {
+    if(!fake::in()) return f();
+    pcgip = cgip; 
+    dynamicval<eGeometry> g(geometry, underlying);
+    dynamicval<eGeometry> gag(actual_geometry, geometry);
+    dynamicval<geometry_information*> gc(cgip, underlying_cgip);
+    dynamicval<hrmap*> gpm(pmap, currentmap);
+    dynamicval<hrmap*> gm(currentmap, get_umap());
+    return f();
+    }
+  
+  #define FPIU(x) hr::fake::in_underlying_geometry([&] { return (x); })
+  #endif
+
+EX hyperpoint befake(hyperpoint h) {
+  auto h1 = h / h[LDIM] * scale;
+  h1[LDIM] = 1;
+  if(material(h1) > 1e-3)
+    h1 = normalize(h1);
+  return h1;
+  }
+
+EX vector<hyperpoint> befake(const vector<hyperpoint>& v) {
+  vector<hyperpoint> res;
+  for(auto& h: v) res.push_back(befake(h));
+  return res;
+  }
+
+EX vector<vector<hyperpoint>> befake(const vector<vector<hyperpoint>>& v) {
+  vector<vector<hyperpoint>> res;
+  for(auto& h: v) res.push_back(befake(h));
+  return res;
+  }
+
+EX ld compute_around(bool setup) {
+  auto &ucgi = *underlying_cgip;
+  
+  auto fcs = befake(ucgi.heptshape->faces);
+  
+  if(setup) {
+    cgi.heptshape->faces = fcs;
+    cgi.heptshape->compute_hept();
+    }
+  
+  hyperpoint h = Hypc;
+  for(int i=0; i<ucgi.face; i++) h += fcs[0][i];
+  if(material(h) > 0)
+    h = normalize(h);
+  
+  if(setup)
+    cgi.adjcheck = 2 * hdist0(h);
+
+  hyperpoint h2 = rspintox(h) * xpush0(2 * hdist0(h));
+  
+  auto kh= kleinize(h);
+  auto k0 = kleinize(fcs[0][0]);
+  auto k1 = kleinize(fcs[0][1]);
+  
+  auto vec = k1 - k0;
+  
+  // u = fcs[0] + vec * z
+
+  // (f1-u) | (vec-u) = 0
+  // (f1 - f0 + vec*z) | 
+  
+  // (vec | h2-vec*z)  == (vec | h2) - (vec | vec*z) == 0
+  
+  auto z = (vec|(kh-k0)) / (vec|vec);
+  
+  hyperpoint u = k0 + vec * z;
+
+  if(material(u) <= 0) 
+    return HUGE_VAL;
+
+  u = normalize(u);
+  
+  h2 = spintox(u) * h2;
+  u = spintox(u) * u;
+  
+  h2 = gpushxto0(u) * h2;
+  u = gpushxto0(u) * u;
+
+  ld x = hypot(h2[1], h2[2]);
+  ld y = h2[0];
+  
+  ld ans = 360 / (90 + atan(y/x) / degree);
+  
+  return ans;
+  }
+
+EX void generate() {
+  FPIU( cgi.require_basics() );
+  #if MAXMDIM >= 4
+  auto &ucgi = *underlying_cgip;
+  
+  cgi.loop = ucgi.loop;
+  cgi.face = ucgi.face;
+  cgi.schmid = ucgi.schmid;
+
+  auto& hsh = get_hsh();
+  
+  hsh = *ucgi.heptshape;
+
+  for(int b=0; b<32; b++)
+    cgi.spins[b] = ucgi.spins[b];
+  
+  compute_around(true);
+  hsh.compute_hept();
+  reg3::compute_ultra();
+  
+  reg3::generate_subcells();
+  if(variation == eVariation::coxeter) {
+    for(int i=0; i<isize(cgi.subshapes); i++) {
+      auto& s = cgi.subshapes[i];
+      s.faces_local = ucgi.subshapes[i].faces_local;
+      for(auto &face: s.faces_local) for(auto& v: face) {
+        v = kleinize(v);
+        for(int i=0; i<3; i++) v[i] *= scale;
+        }
+      reg3::make_vertices_only(s.vertices_only, s.faces_local);
+      }
+    }
+  #endif
+  }
+
+int get_middle() {
+  if(S7 == 20) return 5;
+  if(S7 == 8) return 4;
+  return 3;
+  }
+
+EX ld around;
+
+/** @brief the value of 'around' which makes the tiling Euclidean */
+EX ld compute_euclidean() {
+  #if CAP_ARCM
+  if(arcm::in()) return arcm::current.N * 2 / arcm::current.euclidean_angle_sum;
+  #endif
+  if(underlying == gAperiodicHat) return 6;
+  if(WDIM == 2) return 4 / (S7-2.) + 2;
+
+
+  if(underlying == gRhombic3) return 3;
+  if(underlying == gBitrunc3) return 2.55208;
+  int middle = get_middle();
+
+  if(!fake::in()) underlying_cgip = cgip;
+    
+  return M_PI / asin(cos(M_PI/middle) / sin(M_PI/underlying_cgip->face));
+  }
+
+EX ld around_orig() {
+  #if CAP_ARCM
+  if(arcm::in())
+    return arcm::current.N;
+  #endif
+  if(hat::in()) return 6;
+  if(WDIM == 2)
+    return S3;
+  if(underlying == gRhombic3)
+    return 3;
+  if(underlying == gBitrunc3)
+    return 2.24259;
+  return
+    geometry == gFake ? underlying_cgip->loop : cgi.loop;
+  }
+
+EX geometryinfo1 geometry_of_curvature(ld curvature, int dim) {
+  if(curvature == 0)
+    return WDIM == 3 ? giEuclid3 : giEuclid2;
+
+  if(curvature < 0)
+    return WDIM == 3 ? giHyperb3 : giHyperb2;
+    
+  return WDIM == 3 ? giSphere3 : giSphere2;
+  }
+
+EX void compute_scale() {
+
+  ld good = compute_euclidean();
+  
+  if(around < 0) around = good;
+  
+  if(abs(good - around) < 1e-6) good = around;
+  
+  int s3 = around_orig();
+
+  multiple = false;
+  int mcount = int(around / s3 + .5);
+  multiple = abs(around - mcount * s3) < 1e-6;
+  
+  ginf[gFake].g = geometry_of_curvature(good - around, WDIM);
+
+  ld around_ideal = 1/(1/2. - 1./get_middle());
+  
+  bool have_ideal = abs(around_ideal - around) < 1e-6;
+  if(underlying == gRhombic3 || underlying == gBitrunc3) have_ideal = false;
+  
+  finalizer f([&] {if(vid.always3 && WDIM == 2) {
+    geom3::ginf_backup[gFake] = ginf[gFake];
+    geom3::apply_always3_to(ginf[gFake]);
+    }});
+
+  if(arcm::in()) {
+    ginf[gFake].tiling_name = "(" + ginf[gArchimedean].tiling_name + ")^" + fts(around / around_orig());
+    return;
+    }
+  else if(WDIM == 2) {
+    ginf[gFake].tiling_name = lalign(0, "{", S7, ",", around, "}");
+    return;
+    }
+  else if(euclid) scale = 1;
+  else if(have_ideal) {
+    hyperpoint h0 = underlying_cgip->heptshape->faces[0][0];
+    auto s = kleinize(h0);
+    ld d = hypot_d(LDIM, s);
+    scale = 1/d;
+
+    hyperpoint h = h0;
+    auto h1 = h / h[WDIM] * scale;
+    h1[WDIM] = 1;
+    set_flag(ginf[gFake].flags, qIDEAL, true);
+    set_flag(ginf[gFake].flags, qULTRA, false);
+    }
+  else {
+    set_flag(ginf[gFake].flags, qIDEAL, false);
+    set_flag(ginf[gFake].flags, qULTRA, around > around_ideal);
+    ld minscale = 0, maxscale = 10;
+    for(int it=0; it<100; it++) {
+      scale = (minscale + maxscale) /  2;
+      ld ar = compute_around(false);
+      if(sphere) {
+        if(ar < around) maxscale = scale;
+        else minscale = scale;
+        }
+      else {
+        if(ar > around) maxscale = scale;
+        else minscale = scale;
+        }
+      }
+    
+    /* ultra a bit earlier */    
+    if(underlying == gRhombic3 || underlying == gBitrunc3) {
+      auto fcs = befake(underlying_cgip->heptshape->faces[0][0]);
+      set_flag(ginf[gFake].flags, qULTRA, material(fcs) < 0);
+      }
+    }
+  
+  auto& u = underlying_cgip;
+  ginf[gFake].tiling_name = lalign(0, "{", u->face, ",", get_middle(), ",", around, "}");
+  }
+
+void set_gfake(ld _around) {
+  cgi.require_basics();
+  underlying = geometry;
+  underlying_cgip = cgip;  
+  ginf[gFake] = ginf[underlying];
+  
+  geometry = gFake;
+  
+  around = _around;
+  
+  compute_scale();
+  check_cgi();
+  cgi.require_basics();
+
+  if(currentmap) new hrmap_fake(currentmap);
+  if(hat::in()) hat::reshape();
+  }
+
+EX void change_around() {
+  if(around >= 0 && around <= 2) return;
+
+  ld t = in() ? scale : 1;
+  hyperpoint h = inverse_exp(shiftless(tC0(View)));
+  transmatrix T = gpushxto0(tC0(View)) * View;
+  
+  ld range = sightranges[geometry];
+  
+  if(!fake::in()) {
+    underlying = geometry;
+    if(around == around_orig()) return; /* do nothing */
+    set_gfake(around);
+    }
+  
+  else {    
+    compute_scale();
+    ray::reset_raycaster();
+
+    /* to compute scale */
+    if(WDIM == 2)
+      cgi.require_basics();
+    }
+
+  t = scale / t;
+  h *= t;
+  View = rgpushxto0(direct_exp(h)) * T;
+  fixmatrix(View);
+  
+  sightranges[gFake] = range * t;
+  #if CAP_TEXTURE
+  texture::config.remap();
+  #endif
+  geom3::apply_always3();
+  }
+
+EX void configure() {
+  if(!in()) {
+    underlying_cgip = cgip;
+    around = around_orig();
+    }
+  dialog::editNumber(around, 2.01, 10, 1, around, XLAT("fake curvature"), 
+    XLAT(
+    "This feature lets you construct the same tiling, but "
+    "from shapes of different curvature.\n\n"
+    "The number you give here is (2D) vertex degree or (3D) "
+    "the number of cells around an edge.\n\n")
+    );
+  if(fake::in())
+    dialog::get_di().reaction = change_around;
+  else  
+    dialog::get_di().reaction_final = change_around;
+  dialog::get_di().extra_options = [] {
+    ld e = compute_euclidean();
+    dialog::addSelItem(XLAT("Euclidean"), fts(e), 'E');
+    dialog::add_action([e] {
+      around = e;
+      popScreen();
+      change_around();
+      });
+
+    dialog::addSelItem(XLAT("original"), fts(around_orig()), 'O');
+    dialog::add_action([] {
+      around = around_orig();
+      popScreen();
+      change_around();
+      });
+
+    dialog::addSelItem(XLAT("double original"), fts(2 * around_orig()), 'D');
+    dialog::add_action([] {
+      around = 2 * around_orig();
+      popScreen();
+      change_around();
+      });
+    
+    dialog::addBoolItem_action(XLAT("draw all if multiple of original"), multiple_special_draw, 'M');
+    dialog::addBoolItem_action(XLAT("draw copies (2D only)"), recursive_draw, 'C');
+
+    dialog::addBoolItem_choice(XLAT("unordered"), ordered_mode, 0, 'U');
+    dialog::addBoolItem_choice(XLAT("pre-ordered"), ordered_mode, 1, 'P');
+    dialog::addBoolItem_choice(XLAT("post-ordered"), ordered_mode, 2, 'Q');
+
+    };
+  }
+  
+#if CAP_COMMANDLINE
+int readArgs() {
+  using namespace arg;
+           
+  if(0) ;
+  else if(argis("-gfake-euc")) {
+    start_game();
+    around = compute_euclidean();
+    change_around();
+    }
+  else if(argis("-gfake")) {
+    start_game();
+    shift_arg_formula(around, change_around);
+    }
+  else if(argis("-gfake-order")) {
+    shift(); ordered_mode = argi();
+    }
+  else return 1;
+  return 0;
+  }
+
+auto fundamentalhook = addHook(hooks_args, 100, readArgs);
+#endif
+
+EX }
+
+}
+

flags.cpp

@@ -1,157 +1,147 @@
-// Hyperbolic Rogue
-// implementation of various simple flags for lands, items, monsters, and walls
+// Hyperbolic Rogue - Flags
 
-// Copyright (C) 2011-2018 Zeno Rogue, see 'hyper.cpp' for details
+// Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details
 
+/** \file flags.cpp
+ *  \brief Implementation of various simple flags for lands, items, monsters, and walls.
+ */
+
+#include "hyper.h"
 namespace hr {
 
-bool isIcyLand(eLand l) {
-  return l == laIce || l == laCocytus || l == laBlizzard;
-  }
+#if HDR
+const inline flagtype& classflag(eItem it) { return iinf[it].flags; }
+const inline flagtype& classflag(eWall w) { return winf[w].flags; }
+const inline flagtype& classflag(eMonster m) { return minf[m].flags; }
+const inline flagtype& classflag(eLand l) { return linf[l].flags; }
 
-bool isIcyLand(cell *c) {
-  return isIcyLand(c->land);
-  }
+#define ANYFLAGCHECK(name, cond, field, enum) inline bool name(enum w) { flagtype flag = classflag(w); return cond; } inline bool name(cell *c) { return name(c->field); }
 
-bool isGravityLand(eLand l) {
-  return 
-    l == laIvoryTower || l == laEndorian ||
-    l == laMountain || l == laDungeon;
-  }
+#define MONFLAGCHECK(name, cond) ANYFLAGCHECK(name, cond, monst, eMonster)
+#define WALLFLAGCHECK(name, cond) ANYFLAGCHECK(name, cond, wall, eWall)
+#define ITEMFLAGCHECK(name, cond) ANYFLAGCHECK(name, cond, item, eItem)
+#define LANDFLAGCHECK(name, cond) ANYFLAGCHECK(name, cond, land, eLand)
 
-bool isEquidLand(eLand l) {
-  return 
-    l == laIvoryTower || l == laEndorian || l == laDungeon ||
-    isHaunted(l) || l == laOcean;
-  }
+WALLFLAGCHECK(isWatery, flag & WF_WATER)
+WALLFLAGCHECK(isBoat, flag & WF_BOAT)
+WALLFLAGCHECK(isChasmy, flag & WF_CHASM)
+WALLFLAGCHECK(isWateryOrBoat, (flag & WF_WATER) || w == waBoat)
+WALLFLAGCHECK(isNoFlight, flag & WF_NOFLIGHT)
+WALLFLAGCHECK(isFire, flag & WF_FIRE)
+WALLFLAGCHECK(isThumper, flag & WF_THUMPER)
+WALLFLAGCHECK(isActivable, flag & WF_ACTIVABLE)
+WALLFLAGCHECK(hasTimeout, flag & WF_TIMEOUT)
+WALLFLAGCHECK(isOnCIsland, flag & WF_CISLAND)
+WALLFLAGCHECK(cellHalfvine, flag & WF_HALFVINE)
+WALLFLAGCHECK(isAlch, flag & WF_ALCHEMY)
+WALLFLAGCHECK(isAlchAny, flag & WF_ALCHEMY)
+WALLFLAGCHECK(realred, flag & WF_RED)
+WALLFLAGCHECK(isWall, flag & WF_WALL)
+WALLFLAGCHECK(isNonblock, flag & WF_NONBLOCK)
+WALLFLAGCHECK(isPushable, flag & WF_PUSHABLE)
+WALLFLAGCHECK(conegraphtype, flag & WF_CONE)
+WALLFLAGCHECK(isStandardTree, flag & WF_STDTREE)
+WALLFLAGCHECK(isGrave, flag & WF_GRAVE)
+WALLFLAGCHECK(isReptile, flag & WF_REPTILE)
+WALLFLAGCHECK(useHeatColoring, flag & WF_HEATCOLOR)
+WALLFLAGCHECK(isThorny, flag & WF_THORNY)
+
+LANDFLAGCHECK(generateAll, flag & LF_GENERATE_ALL)
+LANDFLAGCHECK(isIcyLand, flag & LF_ICY)
+LANDFLAGCHECK(isGravityLand, flag & LF_GRAVITY)
+LANDFLAGCHECK(isEquidLand, flag & LF_EQUI)
+LANDFLAGCHECK(isWarpedType, flag & LF_WARPED)
+LANDFLAGCHECK(isCyclic, flag & LF_CYCLIC)
+LANDFLAGCHECK(isTechnicalLand, flag & LF_TECHNICAL)
+LANDFLAGCHECK(is_mirrorland, flag & LF_MIRROR)
+LANDFLAGCHECK(isSealand, flag & LF_SEA)
+LANDFLAGCHECK(isCoastal, flag & LF_COASTAL)
+LANDFLAGCHECK(isPureSealand, flag & LF_PURESEA)
+LANDFLAGCHECK(isElemental, flag & LF_ELEMENTAL)
+LANDFLAGCHECK(isHaunted, flag & LF_HAUNTED)
+LANDFLAGCHECK(isTrollLand, flag & LF_TROLL)
+LANDFLAGCHECK(inmirror, flag & LF_INMIRROR)
+LANDFLAGCHECK(inmirrororwall, flag & LF_INMIRRORORWALL)
+LANDFLAGCHECK(isElectricLand, flag & LF_ELECTRIC)
+
+MONFLAGCHECK(isGhostable, !(flag & CF_NOGHOST))
+MONFLAGCHECK(isRaider, flag & CF_RAIDER)
+MONFLAGCHECK(isMimic, flag & CF_MIMIC)
+MONFLAGCHECK(isPrincess, flag & CF_PRINCESS)
+MONFLAGCHECK(isGolemOrKnight, flag & CF_GOK)
+MONFLAGCHECK(isNonliving, flag & CF_NONLIVING)
+MONFLAGCHECK(isMetalBeast, flag & CF_METAL)
+MONFLAGCHECK(isStunnable, flag & CF_STUNNABLE)
+MONFLAGCHECK(hasHitpoints, flag & CF_HP)
+MONFLAGCHECK(isMountable, flag & CF_MOUNTABLE)
+MONFLAGCHECK(isFriendlyType, flag & CF_FRIENDLY)
+MONFLAGCHECK(isFriendlyOrPlayer, flag & (CF_FRIENDLY | CF_PLAYER))
+MONFLAGCHECK(isBug, flag & CF_BUG)
+MONFLAGCHECK(isIvy, flag & CF_IVY)
+MONFLAGCHECK(isMonsterPart, flag & CF_PART)
+MONFLAGCHECK(isMutantIvy, flag & CF_MUTANTIVY)
+MONFLAGCHECK(isAnyIvy, flag & CF_ANYIVY)
+MONFLAGCHECK(isBulletType, flag & CF_BULLET)
+MONFLAGCHECK(isDemon, flag & CF_DEMON)
+MONFLAGCHECK(isWorm, flag & CF_WORM)
+MONFLAGCHECK(isWitch, flag & CF_WITCH)
+MONFLAGCHECK(isAngryBird, (flag & CF_BIRD) && !(flag & CF_FRIENDLY))
+MONFLAGCHECK(isBird, flag & CF_BIRD)
+MONFLAGCHECK(slowMover, flag & CF_SLOWMOVER)
+MONFLAGCHECK(isMagneticPole, flag & CF_MAGNETIC)
+MONFLAGCHECK(isSwitch, flag & CF_SWITCH)
+MONFLAGCHECK(isGhost, flag & CF_GHOST)
+MONFLAGCHECK(isShark, flag & CF_SHARK)
+MONFLAGCHECK(isSlimeMover, flag & CF_SLIME)
+MONFLAGCHECK(isDragon, flag & CF_DRAGON)
+MONFLAGCHECK(isKraken, flag & CF_KRAKEN)
+MONFLAGCHECK(isBlowableMonster, !(flag & CF_NOBLOW))
+MONFLAGCHECK(isMultitile, flag & CF_MULTITILE)
+MONFLAGCHECK(isLeader, flag & CF_LEADER)
+MONFLAGCHECK(isFlyingType, flag & CF_FLYING)
+MONFLAGCHECK(attackThruVine, flag & CF_ATTACK_THRU_VINE)
+MONFLAGCHECK(attackNonAdjacent, flag & CF_ATTACK_NONADJACENT)
+MONFLAGCHECK(noHighlight, flag & CF_NOHIGHLIGHT)
+MONFLAGCHECK(isInactiveEnemyType, flag & CF_INACTIVE)
+MONFLAGCHECK(isUnarmed, flag & CF_UNARMED)
+MONFLAGCHECK(ignoresPlatesType, flag & CF_IGNORE_PLATE)
+MONFLAGCHECK(isBull, flag & CF_BULL)
+MONFLAGCHECK(isTroll, flag & CF_TROLL)
+MONFLAGCHECK(ignoresSmellType, flag & CF_IGNORE_SMELL)
+MONFLAGCHECK(isRatling, flag & CF_RATLING)
+MONFLAGCHECK(isGhostMover, flag & CF_GHOSTMOVER)
+MONFLAGCHECK(isPowerMonster, flag & CF_POWER)
+MONFLAGCHECK(hasFacing, flag & CF_FACING)
+
+ITEMFLAGCHECK(isElementalShard, flag & IF_SHARD)
+ITEMFLAGCHECK(itemBurns, !(flag & IF_FIREPROOF))
+ITEMFLAGCHECK(isProtectionOrb, flag & IF_PROTECTION)
+ITEMFLAGCHECK(isEmpathyOrb, flag & IF_EMPATHY)
+ITEMFLAGCHECK(isRangedOrb, flag & IF_RANGED)
+ITEMFLAGCHECK(isRevivalOrb, flag & IF_REVIVAL)
+#endif
+
+eMonster movegroup(eMonster m);
 
 // watery
 
-bool isWatery(cell *c) {
-  return c->wall == waCamelotMoat || c->wall == waSea || c->wall == waLake;
-  }
-
-bool isBoat(cell *c) {
-  return among(c->wall, waBoat, waStrandedBoat);
-  }
-
-bool isChasmy(cell *c) {
-  return c->wall == waChasm || c->wall == waSulphur || c->wall == waSulphurC || c->wall == waBubble ||
-    c->wall == waMercury;
-  }
-
-bool isWateryOrBoat(cell *c) {
-  return isWatery(c) || c->wall == waBoat;
-  }
-
-bool isNoFlight(cell *c) {
-  return 
-    c->wall == waBoat || c->wall == waVineHalfA || c->wall == waVineHalfB ||
-    c->wall == waStrandedBoat || c->wall == waTrunk ||
-    c->wall == waBigBush || c->wall == waSmallBush;
-  }
-
-bool boatStrandable(cell *c) {
+EX bool boatStrandable(cell *c) {
   return c->wall == waNone && (c->land == laLivefjord || c->land == laOcean);
   }
 
 // monster/wall types
 
-bool isFire(cell *w) {
-  return w->wall == waFire || w->wall == waPartialFire || w->wall == waEternalFire || w->wall == waBurningDock;
-  }
-
-bool isFireOrMagma(cell *w) {
+EX bool isFireOrMagma(cell *w) {
   return isFire(w) || w->wall == waMagma;
   }
 
-bool isThumper(eWall w) {
-  return w == waThumperOff || w == waThumperOn;
-  }
-
-bool isThumper(cell *c) {
-  return isThumper(c->wall);
-  }
-
-bool isActivable(cell *c) {
-  return c->wall == waThumperOff || c->wall == waBonfireOff;
-  }
-
-bool hasTimeout(cell *c) {
-  return c->wall == waThumperOn || c->wall == waFire || c->wall == waPartialFire ||
-    c->wall == waTempWall || c->wall == waTempFloor || c->wall == waTempBridge ||
-    c->wall == waTempBridgeBlocked || c->wall == waBurningDock;
-  }
-
-bool isMimic(eMonster m) {
-  return m == moMimic;
-  }
-
-int mirrorcolor(bool mirrored) {
+EX int mirrorcolor(bool mirrored) {
   return winf[mirrored ? waMirror : waCloud].color;
   }
 
-bool isMimic(cell *c) { 
-  return isMimic(c->monst);
-  }
-
-bool isPrincess(eMonster m) {
-  return 
-    m == moPrincess || m == moPrincessMoved ||
-    m == moPrincessArmed || m == moPrincessArmedMoved;
-  }
-
-bool isGolemOrKnight(eMonster m) {
-  return 
-    m == moGolem  || m == moGolemMoved || 
-    m == moKnight || m == moKnightMoved ||
-    m == moTameBomberbird  || m == moTameBomberbirdMoved ||
-    m == moMouse || m == moMouseMoved ||
-    m == moFriendlyGhost ||
-    isPrincess(m);
-  }
-
-bool isGolemOrKnight(cell *c) { return isGolemOrKnight(c->monst); }
-
-bool isNonliving(eMonster m) {
-  return 
-    m == moMimic || m == moGolem || m == moGolemMoved ||
-    m == moZombie || m == moGhost || m == moShadow || m == moSkeleton ||
-    m == moEvilGolem || m == moIllusion || m == moEarthElemental || 
-    m == moWaterElemental || m == moDraugr || m == moTerraWarrior ||
-    m == moIceGolem || m == moVoidBeast || m == moJiangshi;
-  }
-
-bool isMetalBeast(eMonster m) {
-  return m == moMetalBeast || m == moMetalBeast2;
-  }
-
-bool isStunnable(eMonster m) {
-  return m == moPalace || m == moFatGuard || m == moSkeleton || isPrincess(m) ||
-    isMetalBeast(m) || m == moTortoise || isDragon(m) ||
-    m == moReptile || m == moTerraWarrior || m == moSalamander ||
-    m == moVizier;
-  }
-
-bool hasHitpoints(eMonster m) {
-  return m == moPalace || m == moFatGuard || m == moVizier || isPrincess(m) || m == moTerraWarrior;
-  }
-
-bool isMountable(eMonster m) {
-  return isWorm(m) && m != moTentacleGhost;
-  }
-
-bool isFriendly(eMonster m) {
-  return isMimic(m) || isGolemOrKnight(m) || m == moIllusion || m == moFriendlyIvy;
-  }
-
-bool isFriendlyOrPlayer(eMonster m) {
-  return isFriendly(m) || m == moPlayer;
-  }
-
-bool isMounted(cell *c) {
+EX bool isMounted(cell *c) {
   if(c && c->monst && c->monst != moTentacleGhost && isMountable(c->monst)) {
-    for(int i=0; i<numplayers(); i++) {
+    for(int i: player_indices()) {
       if(playerpos(i)->monst && sameMonster(c, playerpos(i))) 
         return true;
       if(lastmountpos[i] && lastmountpos[i]->monst && sameMonster(c, lastmountpos[i]))
@@ -161,111 +151,39 @@ bool isMounted(cell *c) {
   return false;
   }
 
-bool isFriendly(cell *c) { 
+EX int itemclass(eItem it) { return iinf[it].itemclass; }
+
+EX bool isFriendly(eMonster m) { return isFriendlyType(m); }
+
+EX bool isFriendly(cell *c) { 
   return isMounted(c) || isFriendly(c->monst); 
   }
 
-bool isBug(eMonster m) {
-  return m >= moBug0 && m < moBug0+BUGCOLORS;
+EX eThreatLevel get_threat_level(cell *c) { 
+  if(!c->monst) return tlNoThreat;
+  if(isFriendly(c)) return tlNoThreat;
+  if(classflag(c->monst) & CF_HIGH_THREAT) return tlHighThreat;
+  if(classflag(c->monst) & CF_SPAM) return tlSpam;
+  return tlNormal;
   }
 
-bool isBug(cell *c) {
-  return isBug(c->monst);
-  }
-
-bool isFriendlyOrBug(cell *c) { // or killable discord!
+EX bool isFriendlyOrBug(cell *c) { // or killable discord!
   // do not attack the stunned Princess
   if(isPrincess(c->monst) && c->stuntime) return false;
   return isFriendly(c) || isBug(c) || (c->monst && markOrb(itOrbDiscord) && !c->stuntime);
   }
 
-bool isIvy(eMonster m) {
-  return m == moIvyRoot || m == moIvyHead || m == moIvyBranch || m == moIvyWait ||
-    m == moIvyNext || m == moIvyDead;
-  }
-
-bool isIvy(cell *c) {
-  return isIvy(c->monst);
-  }
-
-bool isMonsterPart(eMonster m) {
-  return m == moMutant || (isIvy(m) && m != moIvyRoot) ||
-    m == moDragonTail || m == moKrakenT;
-  }
-  
-bool isMutantIvy(eMonster m) {
-  return m == moMutant;
-  }
-
-bool isAnyIvy(eMonster m) {
-  return isIvy(m) || isMutantIvy(m) || m == moFriendlyIvy;
-  }
-
-bool isBulletType(eMonster m) { 
-  return 
-    m == moBullet || m == moFlailBullet || m == moFireball || 
-    m == moTongue || m == moAirball || m == moArrowTrap; 
-  }
-
-bool isMutantIvy(cell *c) { return isMutantIvy(c->monst); }
-
-bool isDemon(eMonster m) {
-  return m == moLesser || m == moLesserM || m == moGreater || m == moGreaterM;
-  }
-
-bool isDemon(cell *c) {
-  return isDemon(c->monst);
-  }
-
-bool isWorm(eMonster m) {
-  return m == moWorm || m == moWormtail || m == moWormwait || 
-    m == moTentacle || m == moTentacletail || m == moTentaclewait ||
-    m == moTentacleEscaping || m == moTentacleGhost ||
-    m == moHexSnake || m == moHexSnakeTail ||
-    m == moDragonHead || m == moDragonTail;
-  }
-
-bool isWorm(cell *c) {
-  return isWorm(c->monst);
-  }
-
-bool isWitch(eMonster m) {
-  // evil golems don't count
-  return m >= moWitch && m < moWitch+NUMWITCH-1;
-  }
-
-bool isOnCIsland(cell *c) {
-  return (c->wall == waCIsland || c->wall == waCTree || c->wall == waCIsland2);
-  }
-
-bool isGhostable(eMonster m) {
-  return m && !isFriendly(m) && !isIvy(m) && !isMultitile(m) && !isMutantIvy(m);
-  }
-
-bool cellUnstable(cell *c) {
+EX bool cellUnstable(cell *c) {
   return (c->land == laMotion && c->wall == waNone) || c->wall == waTrapdoor;
   }
 
-bool cellUnstableOrChasm(cell *c) {
+EX bool cellUnstableOrChasm(cell *c) {
   return 
     (c->land == laMotion && c->wall == waNone) || 
     c->wall == waChasm || c->wall == waTrapdoor;
   }
 
-bool cellHalfvine(cell *c) {
-  return c->wall == waVineHalfA || c->wall == waVineHalfB;
-  }
-
-bool isWarped(eLand l) {
-  return l == laWarpCoast || l == laWarpSea;
-  }
-
-bool isElementalShard(eItem i) {
-  return 
-    i == itFireShard || i == itAirShard || i == itEarthShard || i == itWaterShard;
-  }
-
-eMonster elementalOf(eLand l) {
+EX eMonster elementalOf(eLand l) {
   if(l == laEFire) return moFireElemental;
   if(l == laEWater) return moWaterElemental;
   if(l == laEAir) return moAirElemental;
@@ -273,252 +191,48 @@ eMonster elementalOf(eLand l) {
   return moNone;
   }
 
-eItem localshardof(eLand l) {
+EX eItem localshardof(eLand l) {
   return eItem(itFireShard + (l - laEFire));
   }
 
-int itemclass(eItem i) {
-  if(i == 0) return -1;
-  if(i < itKey || i == itFernFlower || 
-    i == itWine || i == itSilver || i == itEmerald || i == itRoyalJelly || i == itPower ||
-    i == itGrimoire || i == itPirate || i == itRedGem || i == itBombEgg ||
-    i == itCoast || i == itWhirlpool || i == itPalace || i == itFjord ||
-    i == itElemental || i == itZebra || i == itIvory ||
-    i == itBounty || i == itFulgurite || i == itMutant || i == itLotus || i == itMutant2 ||
-    i == itWindstone || i == itCoral || i == itRose ||
-    i == itBabyTortoise || i == itDragon || i == itApple ||
-    i == itKraken || i == itBarrow || i == itTrollEgg || i == itTreat ||
-    i == itSlime || i == itAmethyst || i == itDodeca ||
-    i == itGreenGrass || i == itBull ||
-    i == itLavaLily || i == itHunting ||
-    i == itBlizzard || i == itTerra || i == itGlowCrystal || i == itSnake ||
-    i == itDock || i == itRuins || i == itSwitch || i == itMagnet
-    )
-    return IC_TREASURE;
-  if(i == itSavedPrincess || i == itStrongWind || i == itWarning || i == itBuggy || i == itBuggy2)
-    return IC_NAI;
-  if(i == itKey || i == itOrbYendor || i == itGreenStone || i == itHolyGrail || i == itCompass ||
-    isElementalShard(i) || i == itRevolver || i == itInventory) 
-    return IC_OTHER;  
-  return IC_ORB;
-  }
-  
-bool isAlch(eWall w) {
-  return w == waFloorA || w == waFloorB;
-  }
-
-/* bool isAlch2(eWall w, bool bubbletoo) {
-  return w == waSlime1 || w == waSlime2 || (bubbletoo && w == waBubble);
-  } */
-
-/* bool isAlch2(cell *c, bool bubbletoo) {
-  return isAlch2(c->wall, bubbletoo);
-  } */
-
-bool isAlch(cell *c) { return isAlch(c->wall); }
-  
-bool isAlchAny(eWall w) {
-  return w == waFloorA || w == waFloorB;
-  }
-  
-bool isAlchAny(cell *c) { return isAlchAny(c->wall); }
-  
-bool realred(eWall w) {
-  return w == waRed1 || w == waRed2 || w == waRed3;
-  }
-
-int snakelevel(eWall w) {
-  if(w == waRed1 || w == waDeadfloor2 || w == waRubble || w == waGargoyleFloor || 
-    w == waGargoyleBridge || w == waTempFloor || w == waTempBridge || w == waRoundTable ||
-    w == waPetrifiedBridge || w == waMagma) 
-    return 1;
-  if(w == waRed2) return 2;
-  if(w == waRed3) return 3;
-  if(w == waTower) return 3;
-  return 0;
-  }
-
-int snakelevel(cell *c) { return snakelevel(c->wall); }
-
-bool isWall(cell *w) {
-  if(w->wall == waNone || isAlchAny(w) || 
-    w->wall == waCavefloor || w->wall == waFrozenLake || w->wall == waVineHalfA ||
-    w->wall == waVineHalfB || w->wall == waDeadfloor || w->wall == waDeadfloor2 ||
-    w->wall == waRubble || w->wall == waGargoyleFloor || w->wall == waGargoyleBridge ||
-    w->wall == waTempFloor || w->wall == waTempBridge || w->wall == waPetrifiedBridge ||
-    w->wall == waBoat || w->wall == waCIsland || w->wall == waCIsland2 || 
-    w->wall == waRed1 || w->wall == waRed2 || w->wall == waRed3 ||
-    w->wall == waMineUnknown || w->wall == waMineMine || w->wall == waMineOpen ||
-    w->wall == waStrandedBoat || w->wall == waOpenGate || w->wall == waClosePlate ||
-    w->wall == waOpenPlate || w->wall == waTrapdoor || w->wall == waGiantRug ||
-    w->wall == waLadder || w->wall == waTrunk || w->wall == waSolidBranch ||
-    w->wall == waWeakBranch || w->wall == waCanopy || w->wall == waTower ||
-    w->wall == waSmallBush || w->wall == waBigBush ||
-    w->wall == waReptile || w->wall == waReptileBridge || w->wall == waInvisibleFloor ||
-    w->wall == waSlime1 || w->wall == waSlime2 || w->wall == waArrowTrap || w->wall == waMagma ||
-    w->wall == waDock) 
-    return false;
-  if(isWatery(w) || isChasmy(w) || isFire(w)) return false;
-  return true;
-  }
-
-bool isAngryBird(eMonster m) {
-  return m == moEagle || m == moAlbatross || m == moBomberbird || m == moGargoyle ||
-    m == moWindCrow || m == moSparrowhawk || 
-    m == moVampire || m == moBat || m == moButterfly || m == moGadfly;
-  }
-
-bool isBird(eMonster m) {
-  return isAngryBird(m) || m == moTameBomberbird || m == moTameBomberbirdMoved;
-  }
-
-bool slowMover(eMonster m) {
-  return 
-    m == moLesser || m == moGreater || isMetalBeast(m) ||
-    m == moTortoise || m == moDraugr;
-  }
-
-bool isMagneticPole(eMonster m) {
-  return m == moNorthPole || m == moSouthPole;
-  }
-
-bool normalMover(eMonster m) {
-  return
-    m == moYeti || m == moRanger || m == moGoblin || m == moTroll || m == moDesertman || 
-    m == moMonkey || m == moZombie || m == moNecromancer || m == moCultist || 
-    m == moRunDog || m == moPyroCultist || 
-    m == moFireFairy || m == moCrystalSage || m == moHedge ||
-    m == moVineBeast || m == moLancer || m == moFlailer ||
-    m == moMiner || m == moDarkTroll || 
-    (playerInPower() && (
-      (isWitch(m) && m != moWitchGhost && m != moWitchWinter) || m == moEvilGolem
-      )) ||
-    m == moRedTroll || 
-    m == moPalace || m == moFatGuard || m == moSkeleton || m == moVizier ||
-    m == moFjordTroll || m == moStormTroll || m == moForestTroll ||
-    m == moFamiliar ||
-    m == moFireElemental || m == moOrangeDog ||    
-    m == moOutlaw || m == moRedFox || m == moFalsePrincess || m == moRoseLady ||
-    m == moRoseBeauty || m == moWolf ||
-    m == moResearcher || m == moRagingBull || 
-    m == moNarciss || m == moMirrorSpirit || 
-    m == moHunterDog || m == moTerraWarrior || m == moJiangshi || 
-    m == moLavaWolf || m == moSalamander ||
-    m == moHunterGuard || m == moHunterChanging ||
-    m == moIceGolem || 
-    m == moSwitch1 || m == moSwitch2 || m == moCrusher || m == moPair || 
-    isMagneticPole(m) || 
-    slowMover(m);
-  }
-
-bool isSwitch(eMonster m) {
-  return m == moSwitch1 || m == moSwitch2;
+EX int snakelevel(cell *c) { 
+#if CAP_COMPLEX2
+  if(c->land == laBrownian && among(c->wall, waNone, waMineMine, waFire)) return min(c->landparam / brownian::level, 3);
+#endif
+  return winf[c->wall].snakelevel;
   }
 
 // from-to
 
-bool isGhost(eMonster m) {
-  return m == moGhost || m == moTentacleGhost || m == moFriendlyGhost;
+EX eSlimegroup slimegroup(cell *c) {
+  return winf[c->wall].sg;
   }
 
-bool isGhostMover(eMonster m) {
-  return m == moGhost || m == moGreaterShark || m == moTentacleGhost ||
-    (playerInPower() && (m == moWitchGhost || m == moWitchWinter));
+EX bool isFlying(eMonster m) {
+  return isFlyingType(m) || checkOrb(m, itOrbAether);
   }
 
-bool isShark(eMonster m) {
-  return m == moShark || m == moCShark || m == moGreaterShark;
-  }
-
-bool isSlimeMover(eMonster m) {
-  return
-    m == moSlime || m == moSeep || m == moVineSpirit || m == moParrot;
-  }
-
-bool isDragon(eMonster m) { return m == moDragonHead || m == moDragonTail; }
-
-bool isKraken(eMonster m) { return m == moKrakenH || m == moKrakenT; }
-
-bool isBlowableMonster(eMonster m) {
-  return m && !(
-    isWorm(m) || isIvy(m) || isMutantIvy(m) || isSlimeMover(m) || 
-    m == moGhost || m == moGreaterShark ||
-    m == moWaterElemental || m == moWitchGhost || isMimic(m) ||
-    isKraken(m)
-    );
-  }
-  
-bool isMultitile(eMonster m) {
-  return isWorm(m) || isIvy(m) || isMutantIvy(m) || isKraken(m);
-  }
-  
-bool isSlimeMover(cell *c) {
-  return isSlimeMover(c->monst);
-  }
-  
-int slimegroup(cell *c) {
-  if(c->wall == waCavewall || c->wall == waDeadwall)
-    return 1;
-  if(isWatery(c))
-    return 2;
-  if(c->wall == waFloorA)
-    return 3;
-  if(c->wall == waFloorB)
-    return 4;
-  if(c->wall == waVinePlant || cellHalfvine(c))
-    return 5;
-  if(c->wall == waCTree)
-    return 6;
-  return 0;
-  }
-
-bool isLeader(eMonster m) {
-  return m == moPirate || m == moCultistLeader || m == moViking || m == moRatling || m == moRatlingAvenger;
-  }
-
-bool isFlying(eMonster m) {
-  return isBird(m) || isGhost(m) || m == moAirElemental || isDragon(m) || checkOrb(m, itOrbAether);
-  }
-
-bool survivesChasm(eMonster m) {
+EX bool survivesChasm(eMonster m) {
   return isFlying(m);
   }
 
-bool ignoresPlates(eMonster m) {
-  return m == moMouse || isFlying(m) || m == moIllusion;
+EX bool ignoresPlates(eMonster m) {
+  return ignoresPlatesType(m) || isFlying(m);
   }
 
-bool itemBurns(eItem it) {
-  return it && it != itOrbDragon && it != itOrbFire && it != itDragon && it != itOrbWinter && it != itOrbLava && it != itTreat && it != itLavaLily;
-  }
-
-bool attackThruVine(eMonster m) {
-  return m == moGhost || m == moVineSpirit || m == moFriendlyGhost || m == moTentacleGhost;
-  }
-
-bool attackNonAdjacent(eMonster m) {
-  return m == moGhost || m == moFriendlyGhost || m == moTentacleGhost;
-  }
-
-bool noHighlight(eMonster m) {
-  return
-    (m == moIvyWait || m == moIvyNext || m == moIvyDead);
-  }
-
-bool isInactiveEnemy(cell *w, eMonster forwho) {
-  if(w->monst == moWormtail || w->monst == moWormwait || w->monst == moTentacletail || w->monst == moTentaclewait || w->monst == moHexSnakeTail)
-    return true;
-  if(w->monst == moLesserM || w->monst == moGreaterM)
-    return true;
-  if(w->monst == moIvyRoot || w->monst == moIvyWait || w->monst == moIvyNext || w->monst == moIvyDead)
-    return true;
+EX bool isInactiveEnemy(cell *w, eMonster forwho) {
+  if(forwho != moPlayer) {
+    if(w->monst == moGreaterM || w->monst == moLesserM) return false;
+    if(w->monst == moGreater || w->monst == moLesser) return true;
+    }
+  if(isInactiveEnemyType(w->monst)) return true;
   if(w->monst && ((forwho == moPlayer) ? realstuntime(w) : realstuntime(w) > 1) && !isFriendly(w))
     return true;
   return false;
   }
 
 // forpc = true (for PC), false (for golems)
-bool isActiveEnemy(cell *w, eMonster forwho) {
+EX bool isActiveEnemy(cell *w, eMonster forwho) {
   if(((forwho == moPlayer) ? realstuntime(w) : realstuntime(w) > 1))
     return false;
   if(w->monst == passive_switch) return false;
@@ -528,36 +242,16 @@ bool isActiveEnemy(cell *w, eMonster forwho) {
   return true;
   }
 
-bool isUnarmed(eMonster m) {
-  return 
-    m == moMouse || m == moMouseMoved || m == moPrincess || m == moPrincessMoved ||
-    m == moCrystalSage || m == moVampire || m == moBat;
-  }
-
-bool isArmedEnemy(cell *w, eMonster forwho) {
+EX bool isArmedEnemy(cell *w, eMonster forwho) {
   return w->monst != moCrystalSage && w->monst != moCrusher && isActiveEnemy(w, forwho);
   }
 
-bool isHive(eLand l) {
-  return l == laHive;
-  }
-  
-bool isIcyWall(cell *c) {
-  return c->wall == waNone || c->wall == waIcewall || c->wall == waFrozenLake || c->wall == waLake;
-  }
-
-bool eternalFire(cell *c) {
+EX bool eternalFire(cell *c) {
   return c->land == laDryForest || (c->land == laPower && !smallbounded) || c->land == laMinefield ||
     c->land == laEFire || c->land == laElementalWall;
   }
   
-bool isCyclic(eLand l) {
-  return 
-    l == laWhirlpool || l == laTemple || l == laCamelot || l == laClearing ||
-    l == laMountain;
-  }
-
-bool haveRangedOrb() {
+EX bool haveRangedOrb() {
   return 
     items[itOrbPsi] || items[itOrbDragon] || items[itOrbTeleport] ||
     items[itOrbIllusion] || items[itOrbSpace] || items[itOrbAir] ||
@@ -567,200 +261,136 @@ bool haveRangedOrb() {
     items[itOrbMorph] || items[itOrbPhasing];
   }
 
-bool isOffensiveOrb(eItem it) {
-  return it == itOrbLightning || it == itOrbFlash || it == itOrbThorns ||
-    it == itOrbDragon || it == itOrbStunning || 
-    it == itOrbFreedom || it == itOrbPsi ||
-    it == itOrbSide1 || it == itOrbSide2 || it == itOrbSide3 ||
-    it == itOrbSlaying;
-  }
-
-bool isRangedOrb(eItem i) {
-  return i == itOrbPsi || i == itOrbDragon || i == itOrbTeleport || i == itOrbIllusion ||
-    i == itOrbSpace || i == itOrbAir || i == itOrbFrog ||
-    i == itOrbSummon || i == itOrbMatter || i == itRevolver || i == itOrbStunning ||
-    i == itOrbDomination || i == itOrbNature || i == itOrbDash || i == itOrbMorph;
-  }
-
-bool isProtectionOrb(eItem i) {
-  return i == itOrbWinter || i == itOrbShield || i == itOrbInvis || i == itOrbShell;
-  }
-
-bool isEmpathyOrb(eItem i) {
-  return 
-    i == itOrbFire || i == itOrbDigging || i == itOrbWinter ||
-    i == itOrbUndeath || i == itOrbSpeed || i == itOrbShield ||
-    i == itOrbAether || i == itOrbInvis || i == itOrbThorns ||
-    i == itOrbWater || i == itOrbStone ||
-    i == itOrbSide1 || i == itOrbSide2 || i == itOrbSide3 ||
-    i == itOrbSlaying || i == itOrbFish;
-  }
-
-bool isUtilityOrb(eItem i) {
-  return i == itOrbSpeed || i == itOrbDigging || 
-    i == itOrbSafety || i == itOrbTeleport || i == itOrbAether ||
-    i == itOrbTime || i == itOrbSpace || 
-    i == itOrbSummon || i == itOrbLuck || i == itOrbEnergy ||
-    i == itOrbLava;
-  }
-
-bool isDirectionalOrb(eItem i) {
-  return i == itOrbHorns || i == itOrbBull || i == itOrbSword || i == itOrbSword2;
-  }
-
-bool isRevivalOrb(eItem i) {
-  return i == itOrbLife || i == itOrbFriend || i == itOrbUndeath;
-  }
-
-bool isFriendOrb(eItem i) {
-  return i == itOrbLife || i == itOrbFriend || i == itOrbDiscord || i == itOrbLove ||
-    i == itOrbEmpathy || i == itOrbUndeath;
-  }
-
-bool isFriendlyGhost(eMonster m) {
+EX bool isFriendlyGhost(eMonster m) {
   return m == moFriendlyGhost || (markEmpathy(itOrbAether) && isFriendly(m));
   }
 
-bool survivesWater(eMonster m) {
+EX bool isGhostAether(eMonster m) {
+  return isGhost(m) || checkOrb(m, itOrbAether);
+  }
+
+EX bool survivesWater(eMonster m) {
   return 
     m == moShark || m == moGreaterShark || m == moCShark || 
-    isGhost(m) || m == moWitchGhost || m == moShadow ||
+    isGhostAether(m) || m == moWitchGhost || m == moShadow ||
     isBird(m) || m == moWaterElemental || m == moAirElemental ||
     isWorm(m) || isIvy(m) || isDragon(m) || isKraken(m) ||
     m == moMutant || m == moFriendlyIvy || 
-    (isFriendly(m) && markOrb(itOrbFish)) ||
+    checkOrb(m, itOrbFish) ||
+    among(m, moPike, moRusalka) ||
     m == moTortoise; // Tortoises and Ivies survive, but don't go through water
   }
 
 // survives Mercury or Sulphur or Lava
-bool survivesPoison(eMonster m, eWall p) {
+EX bool survivesPoison(eMonster m, eWall p) {
   return
-    isGhost(m) || m == moWitchGhost || m == moShadow ||
+    isGhostAether(m) || m == moWitchGhost || m == moShadow ||
     isBird(m) || m == moAirElemental || isDragon(m) || isWorm(m);
   }
 
 // flying even if stunned
-bool isPermanentFlying(eMonster m) {
-  return m == moAirElemental || isGhost(m);
+EX bool isPermanentFlying(eMonster m) {
+  return m == moAirElemental || isGhostAether(m);
   }
 
-bool survivesFire(eMonster m) {
+EX bool isLuckyLand(eLand l) {
+  return among(l, laIce, laDesert, laDeadCaves, laOvergrown, laDice);
+  }
+
+EX bool survivesFire(eMonster m) {
   return
-    isGhost(m) || m == moWitchWinter || m == moWitchGhost ||
+    isGhostAether(m) || m == moWitchWinter || m == moWitchGhost ||
     m == moBomberbird || m == moTameBomberbird || m == moTameBomberbirdMoved ||
-    (isFriendly(m) && markOrb(itOrbWinter)) || m == moFireElemental ||
+    checkOrb(m, itOrbWinter) || m == moFireElemental ||
     isDragon(m) || m == moShadow;
   }
 
-bool survivesWall(eMonster m) {
-  return isGhost(m);
+EX bool survivesWall(eMonster m) {
+  return isGhostAether(m);
   }
 
-bool survivesThorns(eMonster m) {
-  return isGhost(m) || m == moSkeleton || m == moDraugr;
+EX bool survivesThorns(eMonster m) {
+  return isGhostAether(m) || m == moSkeleton || m == moDraugr;
   }
 
-bool survivesFall(eMonster m) {
-  return isBird(m) || m == moAirElemental || m == moSkeleton || isDragon(m) || m == moShadow || isGhost(m);
+EX bool survivesFall(eMonster m) {
+  return isBird(m) || m == moAirElemental || m == moSkeleton || isDragon(m) || m == moShadow || isGhostAether(m);
   }
 
-bool isThorny(eWall w) { return w == waRose; }
-
-bool checkOrb(eMonster m1, eItem orb) {
+EX bool checkOrb(eMonster m1, eItem orb) {
   if(m1 == moPlayer) return markOrb(orb);
   if(isFriendly(m1)) return markEmpathy(orb);
   return false;
   }
 
-bool checkOrb2(eMonster m1, eItem orb) {
+EX bool checkOrb2(eMonster m1, eItem orb) {
   if(m1 == moPlayer) return markOrb2(orb);
   if(isFriendly(m1)) return markEmpathy2(orb);
   return false;
   }
 
-bool ignoresSmell(eMonster m) {
-  return 
-    m == moHexSnake || isIvy(m) || isMutantIvy(m) || isGhostMover(m) || isSlimeMover(m) ||
-    m == moRoseLady || checkOrb(m, itOrbBeauty) || checkOrb(m, itOrbAether) || checkOrb(m, itOrbShield);
+EX bool ignoresSmell(eMonster m) {
+  return ignoresSmellType(m) || checkOrb(m, itOrbBeauty) || checkOrb(m, itOrbAether) || checkOrb(m, itOrbShield);
   }
 
-bool isTroll(eMonster m) {
-  return 
-    m == moTroll || m == moRedTroll || m == moDarkTroll ||
-    m == moForestTroll || m == moStormTroll || m == moFjordTroll;
-  }
-
-bool isGrave(eWall w) {
-  return w == waFreshGrave || w == waAncientGrave;
-  }
-
-bool isStandardTree(cell *c) {
-  return c->wall == waBigTree || c->wall == waSmallTree;
-  }
-
-bool highwall(cell *c) {
+EX bool highwall(cell *c) {
   if(c->wall == waGlass) return false;
   if(wmescher && wmspatial && c->wall == waBarrier && c->land == laOceanWall)
     return false;
   // if(wmspatial && isTree(c)) return false;
   if(isGrave(c->wall)) return true;
   if(c->wall == waMirrorWall) return false;
+  if(c->wall == waEditStatue) return false;
   return winf[c->wall].glyph == '#' || c->wall == waClosedGate;
   }
 
-int chasmgraph(cell *c) {
+EX int chasmgraph(cell *c) {
   if(c->wall == waChasm || c->wall == waInvisibleFloor) return 2;
   if(isChasmy(c)) return 1;
   if(isWateryOrBoat(c)) return 1;
+  if(c->wall == waShallow) return 1;
   if(wmescher && c->wall == waBarrier && c->land == laOceanWall) return 1;
   if(c->wall == waReptileBridge) return 1;
   return 0;
   }
 
-bool conegraph(cell *c) {
-  return wmescher && wmspatial && (c->wall == waDune || c->wall == waBigTree || c->wall == waSmallTree || c->wall == waCTree || (c->wall == waBarrier && c->land == laOceanWall));
+EX bool conegraph(cell *c) {
+  return ((wmescher && wmspatial) || wmascii3) && (conegraphtype(c) || (c->wall == waBarrier && c->land == laOceanWall));
   }
 
-bool isReptile(eWall w) {
-  return w == waReptile || w == waReptileBridge; 
+/** Determine the power of a frog monster. Also used to determine whether monster is a frog. */
+EX eItem frog_power(eMonster m) {
+  if(m == moFrog) return itOrbFrog;
+  if(m == moPhaser) return itOrbPhasing;
+  if(m == moVaulter) return itOrbDash;
+  return itNone;
   }
 
-bool isBull(eMonster m) {
-  return m == moRagingBull || m == moHerdBull || m == moSleepBull;
-  }
-
-bool hornStuns(cell *c) {
+EX bool hornStuns(cell *c) {
   eMonster m = c->monst;
   return 
     m == moRagingBull || m == moSleepBull || m == moHerdBull ||
     m == moButterfly || m == moGreater || m == moGreaterM || m == moDraugr ||
     m == moHedge || m == moFlailer || m == moVizier || m == moReptile || m == moSalamander || 
     m == moPair || m == moAltDemon || m == moHexDemon || m == moMonk || m == moCrusher ||
-    attackJustStuns(c, AF_NORMAL);
+    attackJustStuns(c, AF_NORMAL, moNone);
   }
 
-// generate all the world first in the quotient geometry
-bool generateAll(eLand l) {
-  return 
-    l == laIce || l == laDryForest || l == laCocytus || l == laLivefjord ||
-    l == laCaves || l == laCA;
+/** changing this wall for whatever reason may cause the game to crash */
+EX bool do_not_touch_this_wall(cell *c) {
+  return among(c->wall, waMirrorWall, waBarrier, waRoundTable, waWarpGate);
   }
 
-bool isRaider(eMonster m) {
-  return m == moPair || m == moMonk || m == moCrusher || m == moAltDemon || m == moHexDemon;
+EX bool is_paired(eMonster m) {
+  return among(m, moPair, moNorthPole, moSouthPole);
   }
 
-bool isTechnicalLand(eLand l) {
-  return l == laNone || l == laOceanWall || l == laBarrier || l == laCanvas ||
-    l == laHauntedWall || l == laHauntedBorder || l == laCA ||
-    l == laMirrorWall || l == laMirrored || l == laMirrored2 ||
-    l == laMirrorWall2 || l == laMercuryRiver || l == laMemory;
+EX bool isDie(eMonster m) {
+  return among(m, moAnimatedDie, moAngryDie);
   }
 
-bool is_mirrorland(cell *c) {
-  return among(c->land, laMirror, laMirrorOld);
+EX bool isDie(eWall w) {
+  return among(w, waRichDie, waHappyDie);
   }
 
-bool isPushable(eWall w) { return w == waThumperOn; }
-
 }

generators/patterngen.cpp

@@ -444,5 +444,17 @@ void buildAutomatonRule(cell *c) {
     }
   }
 
+/*
+  to drawcell:
+  if(c->type == 6 && c->tmp > 0) {
+    int i = c->tmp;
+    zebra(cellwalker(c, i&15), 1, i>>4, "", 0);
+    }
+  
+  c->item = eItem(c->heat / 4);
+  buildAutomatonRule(c);
+#endif
+*/
+
 // #define BUILDZEBRA
 }

glhr.cpp

@@ -0,0 +1,963 @@
+// Hyperbolic Rogue -- low-level OpenGL routines
+// Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details
+
+/** \file glhr.cpp
+ *  \brief low-level OpenGL routines
+ *
+ *  If CAP_SHADER is 0, OpenGL 1.0 is used.
+ *  If CAP_SHADER is 1, we are using GLSL shaders.
+ */
+
+#include "hyper.h"
+namespace hr {
+
+EX bool detailed_shader = false;
+
+EX namespace glhr {
+EX glvertex pointtogl(const hyperpoint& t) {
+  glvertex h;
+  h[0] = t[0]; h[1] = t[1]; h[2] = t[2]; 
+  if(SHDIM == 4) h[3] = (MDIM == 4) ? t[3] : 1;
+  return h;
+  }
+
+EX hyperpoint gltopoint(const glvertex& t) {
+  hyperpoint h;
+  h[0] = t[0]; h[1] = t[1]; h[2] = t[2]; 
+  if(SHDIM == 4 && MAXMDIM == 4) h[3] = t[3];
+  return h;
+  }
+
+#if CAP_SHADER
+EX bool noshaders = false;
+#endif
+#if !CAP_SHADER
+EX bool noshaders = true;
+#endif
+
+#if HDR
+  inline glvertex makevertex(GLfloat x, GLfloat y, GLfloat z) {
+    #if SHDIM == 3
+    return make_array(x, y, z);
+    #else
+    return make_array<GLfloat>(x, y, z, 1);
+    #endif
+    }
+#endif
+
+EX }
+
+#if CAP_GL
+#ifndef DEBUG_GL
+#define DEBUG_GL 0
+#endif
+
+// Copyright (C) 2011-2018 Zeno Rogue, see 'hyper.cpp' for details
+
+EX void glError(const char* GLcall, const char* file, const int line) {
+  GLenum errCode = glGetError();
+  if(errCode!=GL_NO_ERROR) {
+    println(hlog, hr::format("OPENGL ERROR #%i: in file %s on line %i :: %s",errCode,file, line, GLcall));
+    }
+  }
+
+#if HDR
+struct glwrap {
+  const char* msg;
+  int line;
+  void act(const char *when);
+  glwrap(const char *m, int l) : msg(m), line(l) { act("before"); }
+  ~glwrap() { act("after"); }
+  };
+#define GLWRAP glwrap w##__line(__FILE__, __LINE__)
+#endif
+
+void glwrap::act(const char *when) {
+  GLenum errCode = glGetError();
+  if(errCode!=GL_NO_ERROR) {
+    println(hlog, hr::format("GL error %i %s: %s:%i", errCode, when, msg, line));
+    }
+  }
+
+#if HDR
+#if CAP_SHADER && CAP_NOSHADER
+#define WITHSHADER(x, y) if(glhr::noshaders) y else x
+#else
+#if CAP_NOSHADER
+#define WITHSHADER(x, y) if(1) y
+#else
+#define WITHSHADER(x, y) if(1) x
+#endif
+#endif
+#endif
+
+EX namespace glhr {
+
+EX string to_glsl(ld x) {
+  char buf[64];
+  snprintf(buf, 64, "float(%.10e)", x);
+  return buf;
+  }
+
+#if HDR
+struct glmatrix {
+  GLfloat a[4][4];
+  GLfloat* operator[] (int i) { return a[i]; }
+  const GLfloat* operator[] (int i) const { return a[i]; }
+  GLfloat* as_array() { return a[0]; }
+  const GLfloat* as_array() const { return a[0]; }
+  array<float, 16>& as_stdarray() { return *(array<float, 16>*)this; }
+  const array<float, 16>& as_stdarray() const { return *(array<float, 16>*)this; }
+  };
+
+  struct colored_vertex {
+    glvertex coords;
+    glvec4 color;
+    colored_vertex() {}
+    colored_vertex(GLfloat x, GLfloat y, GLfloat r, GLfloat g, GLfloat b) {
+      coords[0] = x;
+      coords[1] = y;
+      coords[2] = 0;
+      coords[3] = 1;
+      color[0] = r;
+      color[1] = g;
+      color[2] = b;
+      color[3] = 1;
+      }
+    void set_color(color_t col) {
+      for(int i=0; i<4; i++)
+        color[i] = part(col, 3-i) / 255.0;
+      }
+    colored_vertex(hyperpoint h, color_t col) {
+      coords = pointtogl(h);
+      set_color(col);
+      }
+    };
+  
+  struct textured_vertex {
+    glvertex coords;
+    /* texture uses the 'z' for shading with POLY_SHADE_TEXTURE */
+    glvec3 texture;
+    };
+  
+  struct ct_vertex {
+    glvertex coords;
+    glvec4 color;
+    glvec2 texture;
+    ct_vertex() {}
+    ct_vertex(const hyperpoint& h, ld x1, ld y1, ld col) {
+      coords = pointtogl(h);
+      texture[0] = x1;
+      texture[1] = y1;
+      color[0] = color[1] = color[2] = col;
+      color[3] = 1;
+      }
+    };  
+
+#endif
+
+EX bool glew   = false;
+
+bool current_depthtest, current_depthwrite;
+ld fogbase;
+
+#if HDR
+typedef const void *constvoidptr;
+#endif
+
+EX constvoidptr current_vertices, buffered_vertices;
+EX ld current_linewidth;
+
+GLuint buf_current, buf_buffered;
+
+void display(const glmatrix& m) {
+  for(int i=0; i<4; i++) {
+    for(int j=0; j<4; j++)
+      printf("%10.5f", m[i][j]);
+    printf("\n");
+    }
+  printf("\n");
+  }
+
+EX glmatrix operator * (glmatrix m1, glmatrix m2) {
+  glmatrix res;
+  for(int i=0; i<4; i++)
+  for(int j=0; j<4; j++) {
+    res[i][j] = 0;
+    for(int k=0; k<4; k++)
+      res[i][j] += m1[i][k] * m2[k][j];
+    }
+  return res;
+  }
+
+EX glmatrix id = {{{1,0,0,0}, {0,1,0,0}, {0,0,1,0}, {0,0,0,1}}};
+
+EX glmatrix scale(ld x, ld y, ld z) {
+  glmatrix tmp;
+  for(int i=0; i<4; i++)
+  for(int j=0; j<4; j++)
+    tmp[i][j] = (i==j);
+  tmp[0][0] = x;
+  tmp[1][1] = y;
+  tmp[2][2] = z;
+  return tmp;
+  }
+
+EX glmatrix tmtogl(const transmatrix& T) {
+  glmatrix tmp;
+  for(int i=0; i<4; i++)
+  for(int j=0; j<4; j++)
+    tmp[i][j] = T[i][j];
+  return tmp;
+  }
+
+EX transmatrix gltotm(const glmatrix& T) {
+  transmatrix tmp;
+  for(int i=0; i<4; i++)
+  for(int j=0; j<4; j++)
+    tmp[i][j] = T[i][j];
+  return tmp;
+  }
+
+EX glmatrix tmtogl_transpose(const transmatrix& T) {
+  glmatrix tmp;
+  for(int i=0; i<4; i++)
+  for(int j=0; j<4; j++)
+    tmp[i][j] = T[j][i];
+  return tmp;
+  }
+
+EX glmatrix tmtogl_transpose3(const transmatrix& T) {
+  glmatrix tmp;
+  for(int i=0; i<4; i++)
+  for(int j=0; j<4; j++)
+    tmp[i][j] = T[j][i];
+  if(MDIM == 3)
+    for(int i=0; i<4; i++)
+    for(int j=0; j<4; j++)
+      if(i == 3 || j == 3) tmp[j][i] = 0;
+  return tmp;
+  }
+
+EX glmatrix ortho(ld x, ld y, ld z) {
+  return scale(1/x, 1/y, 1/z);
+  }
+
+EX glmatrix& as_glmatrix(GLfloat o[16]) {
+  glmatrix& tmp = (glmatrix&) (o[0]);
+  return tmp;
+  }
+
+EX ld vnear_default = 1e-3;
+EX ld vfar_default = 1e9;
+
+EX glmatrix frustum(ld x, ld y, ld vnear IS(vnear_default), ld vfar IS(vfar_default)) {
+  GLfloat frustum[16] = {
+    GLfloat(1 / x), 0, 0, 0,
+    0, GLfloat(1 / y), 0, 0,
+    0, 0, GLfloat(-(vnear+vfar)/(vfar-vnear)), -1,
+    0, 0, GLfloat(-2*vnear*vfar/(vfar-vnear)), 0};
+  return as_glmatrix(frustum);
+  }
+
+EX glmatrix translate(ld x, ld y, ld z) {
+  glmatrix tmp;
+  for(int i=0; i<4; i++)
+  for(int j=0; j<4; j++)
+    tmp[i][j] = (i==j);
+  tmp[3][0] = x;
+  tmp[3][1] = y;
+  tmp[3][2] = z;
+  return tmp;
+  }
+
+// ** legacy **
+
+// /* shaders */
+
+EX glmatrix projection;
+
+EX void new_projection() {
+  WITHSHADER({
+    projection = id;
+    }, {
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    return;
+    })
+  }
+
+EX void projection_multiply(const glmatrix& m) {
+  WITHSHADER({
+    projection = m * projection;  
+    }, {
+    glMatrixMode(GL_PROJECTION);
+    glMultMatrixf(m.as_array());
+    })
+  }
+
+EX void init();
+
+#if HDR
+struct GLprogram {
+  GLuint _program;
+  GLuint vertShader, fragShader;
+
+  GLint uFog, uFogColor, uColor, tTexture, tInvExpTable, tAirMap, uMV, uProjection, uAlpha, uFogBase, uPP;
+  GLint uPRECX, uPRECY, uPRECZ, uIndexSL, uIterations, uLevelLines, uSV, uRadarTransform;
+  GLint uRotSin, uRotCos, uRotNil;
+  GLint uDepthScaling, uCamera, uDepth;
+  
+  flagtype shader_flags;
+  
+  string _vsh, _fsh;
+  
+  GLprogram(string vsh, string fsh);
+
+  ~GLprogram();
+  };
+#endif
+
+EX shared_ptr<GLprogram> current_glprogram = nullptr;
+
+EX bool debug_gl;
+
+EX int compileShader(int type, const string& s) {
+  GLint status;
+
+  if(debug_gl) {
+    println(hlog, "=== ", full_geometry_name(), " @ ", models::get_model_name(pmodel));
+    int lineno = 1;
+    string cline = "";
+    for(char c: s+"\n") {
+      if(c == '\n') println(hlog, hr::format("%4d : ", lineno), cline), lineno++, cline = "";
+      else cline += c;
+      }
+    println(hlog, "===");
+    }
+  
+  GLint shader = glCreateShader(type);
+  const char *ss = s.c_str();
+  glShaderSource(shader, 1, &ss, NULL);
+  glCompileShader(shader);
+  
+  GLint logLength;
+  glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);
+  if (logLength > 0) {
+    std::vector<char> log(logLength);
+    glGetShaderInfoLog(shader, logLength, &logLength, log.data());
+    string s = log.data();
+    if(logLength > 0)
+      println(hlog, "compiler log (", logLength, "): \n", s);
+    if(debug_gl) {
+      println(hlog, "failed to compile shader -- exit called");
+      exit(1);
+      }
+    }
+  
+  glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
+  if (status == 0) {
+    glDeleteShader(shader);
+    printf("failed to compile shader\n");
+    println(hlog, s);
+    shader = 0;
+    }
+  
+  return shader;
+  }
+
+GLprogram::GLprogram(string vsh, string fsh) {
+  if(noshaders || !vid.usingGL) {
+    uFog = -1;
+    uProjection = -1;
+    uPP = -1;
+    uMV = -1;
+    uPRECX = -1;
+    uIterations = -1;
+    uAlpha = -1;
+    uLevelLines = -1;
+    uFogColor = -1;
+    uDepthScaling = uCamera = uDepth = -1;
+    
+    uColor = tTexture = tInvExpTable = tAirMap = -1;
+    uFogBase = -1;
+    uPRECX = uPRECY = uPRECZ = uIndexSL = -1;
+    uSV = uRadarTransform = -1;
+
+    uRotCos = -1;
+    uRotSin = -1;
+    uRotNil = -1;
+    return;    
+    }
+  
+  _vsh = vsh; _fsh = fsh;
+  _program = glCreateProgram();
+  
+  add_fixed_functions(vsh);
+  add_fixed_functions(fsh);
+  
+  // printf("creating program %d\n", _program);
+  vertShader = compileShader(GL_VERTEX_SHADER, vsh.c_str());
+  fragShader = compileShader(GL_FRAGMENT_SHADER, fsh.c_str());
+
+  // Attach vertex shader to program.
+  glAttachShader(_program, vertShader);
+  
+  // Attach fragment shader to program.
+  glAttachShader(_program, fragShader);
+  
+  glBindAttribLocation(_program, aPosition, "aPosition");
+  glBindAttribLocation(_program, aTexture, "aTexture");
+  glBindAttribLocation(_program, aColor, "aColor");
+
+  GLint status;
+  glLinkProgram(_program);
+    
+  GLint logLength;
+  glGetProgramiv(_program, GL_INFO_LOG_LENGTH, &logLength);
+  if (logLength > 0) {
+    std::vector<char> log(logLength);
+    glGetProgramInfoLog(_program, logLength, &logLength, log.data());
+    if(logLength > 0)
+      printf("linking log (%d): %s\n", logLength, log.data());
+    }
+   
+  glGetProgramiv(_program, GL_LINK_STATUS, &status);
+  if (status == 0) {
+    printf("failed to link shader\n");
+    exit(1);
+    }
+  
+  uMV = glGetUniformLocation(_program, "uMV");
+  uProjection = glGetUniformLocation(_program, "uP");
+  uPP = glGetUniformLocation(_program, "uPP");
+  uFog = glGetUniformLocation(_program, "uFog");
+  uFogColor = glGetUniformLocation(_program, "uFogColor");
+  uFogBase = glGetUniformLocation(_program, "uFogBase");
+  uAlpha = glGetUniformLocation(_program, "uAlpha");
+  uColor = glGetUniformLocation(_program, "uColor");
+  tTexture = glGetUniformLocation(_program, "tTexture");
+  tInvExpTable = glGetUniformLocation(_program, "tInvExpTable");
+  tAirMap = glGetUniformLocation(_program, "tAirMap");
+
+  uDepth = glGetUniformLocation(_program, "uDepth");
+  uDepthScaling = glGetUniformLocation(_program, "uDepthScaling");
+  uCamera = glGetUniformLocation(_program, "uCamera");
+
+  uPRECX = glGetUniformLocation(_program, "PRECX");
+  uPRECY = glGetUniformLocation(_program, "PRECY");
+  uPRECZ = glGetUniformLocation(_program, "PRECZ");
+  uIndexSL = glGetUniformLocation(_program, "uIndexSL");
+  uSV = glGetUniformLocation(_program, "uSV");
+  uIterations = glGetUniformLocation(_program, "uIterations");  
+  uLevelLines = glGetUniformLocation(_program, "uLevelLines");
+  uRadarTransform = glGetUniformLocation(_program, "uRadarTransform");
+
+  uRotCos = glGetUniformLocation(_program, "uRotCos");
+  uRotSin = glGetUniformLocation(_program, "uRotSin");
+  uRotNil = glGetUniformLocation(_program, "uRotNil");
+  }
+
+GLprogram::~GLprogram() {
+  glDeleteProgram(_program);
+  if(vertShader) glDeleteShader(vertShader), vertShader = 0;
+  if(fragShader) glDeleteShader(fragShader), fragShader = 0;
+  }
+
+EX void set_index_sl(ld x) {
+  glUniform1f(glhr::current_glprogram->uIndexSL, x);
+  }
+
+EX void set_sv(ld x) {
+  glUniform1f(glhr::current_glprogram->uSV, x);
+  }
+
+EX void set_sl_iterations(int steps) {
+  glUniform1i(glhr::current_glprogram->uIterations, steps);
+  }
+
+EX void set_solv_prec(int x, int y, int z) {
+  glUniform1i(glhr::current_glprogram->tInvExpTable, INVERSE_EXP_BINDING);
+  glUniform1f(glhr::current_glprogram->uPRECX, x);
+  glUniform1f(glhr::current_glprogram->uPRECY, y);
+  glUniform1f(glhr::current_glprogram->uPRECZ, z);
+  }
+
+EX glmatrix current_matrix, current_modelview, current_projection;
+
+bool operator == (const glmatrix& m1, const glmatrix& m2) {
+  for(int i=0; i<4; i++) 
+    for(int j=0; j<4; j++)
+      if(m1[i][j] != m2[i][j]) return false;
+  return true;
+  }
+
+bool operator != (const glmatrix& m1, const glmatrix& m2) {
+  return !(m1 == m2);
+  }
+
+EX glmatrix eyeshift;
+EX bool using_eyeshift;
+
+EX void set_modelview(const glmatrix& modelview) {
+  #if CAP_NOSHADER
+  if(noshaders) {
+    glMatrixMode(GL_MODELVIEW);
+    glLoadMatrixf(modelview.as_array());
+    return;
+    }
+  #endif
+  auto& cur = current_glprogram;
+  if(!cur) return;
+
+  if(detailed_shader) println(hlog, "\n*** ENABLING MODELVIEW:\n", modelview.as_stdarray());
+  if(detailed_shader) println(hlog, "\n*** ENABLING PROJECTION:\n", projection.as_stdarray());
+
+  if(using_eyeshift) {
+    glmatrix mvp = modelview * eyeshift;
+    #if MINIMIZE_GL_CALLS
+    if(mvp == current_matrix) return;
+    current_matrix = mvp;
+    #endif
+    glUniformMatrix4fv(cur->uMV, 1, 0, mvp.as_array());
+    }
+  else if(modelview != current_modelview) {
+    current_modelview = modelview;
+    glUniformMatrix4fv(cur->uMV, 1, 0, modelview.as_array());
+    }
+  if(projection != current_projection) {
+    current_projection = projection;
+    glUniformMatrix4fv(cur->uProjection, 1, 0, projection.as_array());
+    }
+  }
+
+EX void id_modelview() {
+  #if CAP_NOSHADER
+  if(noshaders) {
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    return;
+    }
+  #endif
+  set_modelview(id);
+  }
+
+EX array<GLfloat, 4> acolor(color_t color, ld scale IS(1)) {
+  array<GLfloat, 4> cols;
+  for(int i=0; i<4; i++)
+    cols[i] = part(color, 3-i) / 255.0 * scale;
+  return cols;
+  }
+
+
+EX void color2(color_t color, ld scale IS(1)) {
+  auto cols = acolor(color, scale);
+    
+  WITHSHADER({
+    if(!current_glprogram) return;
+    glUniform4f(current_glprogram->uColor, cols[0], cols[1], cols[2], cols[3]);
+    }, {
+    glColor4f(cols[0], cols[1], cols[2], cols[3]);
+    }
+    )
+  }
+
+EX void colorClear(color_t color) {
+  glClearColor(part(color, 3) / 255.0, part(color, 2) / 255.0, part(color, 1) / 255.0, part(color, 0) / 255.0);
+}
+
+EX void full_enable(shared_ptr<GLprogram> p) {
+  auto& cur = current_glprogram;
+  flagtype oldflags = cur ? cur->shader_flags : 0;
+  if(p == cur) return;
+  if(!vid.usingGL) return;
+  cur = p;
+  GLERR("pre_switch_mode");
+  WITHSHADER({
+    if(detailed_shader) println(hlog, "\n*** ENABLING VERTEX SHADER:\n", cur->_vsh, "\n\nENABLING FRAGMENT SHADER:\n", cur->_fsh, "\n");
+    glUseProgram(cur->_program);
+    GLERR("after_enable");
+    }, {
+    });
+  reset_projection();
+  flagtype newflags = cur->shader_flags;
+  tie(oldflags, newflags) = make_pair(oldflags & ~newflags, newflags & ~oldflags);
+
+  if(newflags & GF_TEXTURE) {
+    GLERR("xsm");
+    WITHSHADER({
+      glEnableVertexAttribArray(aTexture);
+      GLERR("xsm");
+      }, {
+      glEnable(GL_TEXTURE_2D);
+      glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+      GLERR("xsm");
+      })
+    }
+  if(oldflags & GF_TEXTURE) {
+    GLERR("xsm");
+    WITHSHADER({
+      glDisableVertexAttribArray(aTexture);
+      GLERR("xsm");
+      }, {
+      glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+      glDisable(GL_TEXTURE_2D);
+      GLERR("xsm");
+      })
+    }
+  if(newflags & GF_VARCOLOR) {
+    WITHSHADER({
+      GLERR("xsm");
+      glEnableVertexAttribArray(aColor);
+      }, {
+      GLERR("xsm");
+      glEnableClientState(GL_COLOR_ARRAY);
+      GLERR("xsm");
+      })
+    }
+  if(oldflags & GF_VARCOLOR) {
+    WITHSHADER({
+      glDisableVertexAttribArray(aColor);
+      GLERR("xsm");
+      }, {
+      glDisableClientState(GL_COLOR_ARRAY);
+      GLERR("xsm");
+      })
+    }
+  if(newflags & GF_LIGHTFOG) {
+    #ifdef GLES_ONLY
+    #define glFogi glFogx
+    #endif
+    WITHSHADER({}, {
+    /*GLfloat light_ambient[] = { 3.5, 3.5, 3.5, 1.0 };
+    GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
+    GLfloat light_position[] = { 0.0, 0.0, 0.0, 1.0 };
+  
+    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
+    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
+    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
+  
+    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
+    GLERR("lighting");
+  
+    glEnable(GL_LIGHTING);
+    glEnable(GL_LIGHT0); */
+ 
+    glEnable(GL_FOG);
+    glFogi(GL_FOG_MODE, GL_LINEAR);
+    glFogf(GL_FOG_START, 0);
+    })
+    }
+  if(oldflags & GF_LIGHTFOG) {
+    WITHSHADER({}, {glDisable(GL_FOG);})
+    }
+  WITHSHADER({
+    glUniform1f(cur->uFogBase, 1); fogbase = 1;
+    }, {})
+  GLERR("after_switch_mode");
+  current_vertices = NULL;
+  WITHSHADER({
+    current_matrix[0][0] = -1e8; // invalid
+    current_modelview[0][0] = -1e8;
+    current_projection[0][0] = -1e8;
+    }, {})
+  id_modelview();
+  #if MINIMIZE_GL_CALLS
+  #else
+  current_linewidth = -1;
+  #endif
+  /* if(current_depthwrite) glDepthMask(GL_TRUE);
+  else glDepthMask(GL_FALSE);
+  if(current_depthtest) glEnable(GL_DEPTH_TEST);
+  else glDisable(GL_DEPTH_TEST); */
+  }
+
+EX void fog_max(ld fogmax, color_t fogcolor) {
+  WITHSHADER({
+    if(current_glprogram->uFog != -1)
+      glUniform1f(current_glprogram->uFog, 1 / fogmax);
+  
+    if(current_glprogram->uFogColor != -1) {
+      GLfloat cols[4];
+      for(int i=0; i<4; i++) cols[i] = part(fogcolor, 3-i) / 255.0;
+        glUniform4f(current_glprogram->uFogColor, cols[0], cols[1], cols[2], cols[3]);
+      }
+    }, {
+    glFogf(GL_FOG_END, fogmax);
+    })
+  }
+
+EX void set_fogbase(ld _fogbase) {
+  WITHSHADER({
+    if(fogbase != _fogbase) {
+      fogbase = _fogbase;
+      glUniform1f(current_glprogram->uFogBase, fogbase);
+      }
+    }, {})
+  }
+
+EX void set_ualpha(ld alpha) {
+  WITHSHADER({
+    glUniform1f(current_glprogram->uAlpha, alpha);
+    }, {})
+  }
+
+void init() {
+
+  #if CAP_GLEW
+    if(!glew) { 
+      glew = true; 
+      glewExperimental = GL_TRUE;
+      printf("Initializing GLEW\n");
+      GLenum err = glewInit();
+      if (GLEW_OK != err) {
+        addMessage("Failed to initialize GLEW");
+        printf("Failed to initialize GLEW\n");
+        return;
+        }
+      printf("CreateProgram = %p\n", reinterpret_cast<void*>(__glewCreateProgram));
+      if(!__glewCreateProgram) noshaders = true;
+      }
+  #endif
+  
+  projection = id;
+
+  WITHSHADER(glEnableVertexAttribArray(aPosition);, glEnableClientState(GL_VERTEX_ARRAY);)
+  GLERR("aPosition");
+  // #endif
+  
+  glDisableVertexAttribArray(aTexture);
+  glDisableVertexAttribArray(aColor);
+
+  #if CAP_VERTEXBUFFER
+  glGenBuffers(1, &buf_current);
+  glGenBuffers(1, &buf_buffered);
+  current_vertices = NULL;
+  buffered_vertices = (void*) &buffered_vertices; // point to nothing
+  glBindBuffer(GL_ARRAY_BUFFER, buf_current);
+  #endif
+  }
+
+#if CAP_VERTEXBUFFER
+template<class T> void bindbuffer(T& v) {
+  if(current_vertices == buffered_vertices || current_vertices == nullptr) {
+    glBindBuffer(GL_ARRAY_BUFFER, buf_current);
+    }
+  current_vertices = &v[0];
+  glBufferData(GL_ARRAY_BUFFER, isize(v) * sizeof(v[0]), &v[0], GL_DYNAMIC_DRAW);    
+  }
+
+#define PTR(attrib, q, field) \
+  glVertexAttribPointer(attrib, q, GL_FLOAT, GL_FALSE, sizeof(v[0]), (void*) ((char*) &v[0].field - (char*) &v[0]));
+
+EX void bindbuffer_vertex(vector<glvertex>& v) {
+  bindbuffer(v);
+  }
+
+#endif
+
+EX void vertices(const vector<glvertex>& v, int vshift IS(0)) {
+  #if CAP_VERTEXBUFFER
+  if(&v[0] == buffered_vertices) {
+    if(&v[0] == current_vertices) return;
+    current_vertices = buffered_vertices;
+    glBindBuffer(GL_ARRAY_BUFFER, buf_buffered);
+    glVertexAttribPointer(aPosition, SHDIM, GL_FLOAT, GL_FALSE, sizeof(glvertex), 0);
+    return;
+    }
+  bindbuffer(v);
+  glVertexAttribPointer(aPosition, SHDIM, GL_FLOAT, GL_FALSE, sizeof(glvertex), 0);
+  #else
+  if(current_vertices == &v[vshift]) return;
+  current_vertices = &v[vshift];
+  WITHSHADER(
+    glVertexAttribPointer(aPosition, SHDIM, GL_FLOAT, GL_FALSE, sizeof(glvertex), &v[vshift]);,
+    glVertexPointer(SHDIM, GL_FLOAT, sizeof(glvertex), &v[0]);
+    )
+  #endif
+  }
+
+EX void vertices_texture(const vector<glvertex>& v, const vector<glvertex>& t, int vshift IS(0), int tshift IS(0)) {
+  #if CAP_VERTEXBUFFER
+  int q = min(isize(v)-vshift, isize(t)-tshift);
+  vector<textured_vertex> tv(q);
+  for(int i=0; i<q; i++)
+    tv[i].coords = v[vshift+i],
+    tv[i].texture[0] = t[tshift+i][0],
+    tv[i].texture[1] = t[tshift+i][1],
+    tv[i].texture[2] = t[tshift+i][2];
+  prepare(tv);
+  #else
+  vertices(v, vshift);
+  WITHSHADER(
+    glVertexAttribPointer(aTexture, SHDIM, GL_FLOAT, GL_FALSE, sizeof(glvertex), &t[tshift]);,
+    glTexCoordPointer(SHDIM, GL_FLOAT, 0, &t[tshift]);
+    )
+  #endif
+  }
+
+EX void vertices_texture_color(const vector<glvertex>& v, const vector<glvertex>& t, const vector<glvertex>& c, int vshift IS(0), int tshift IS(0)) {
+  #if CAP_VERTEXBUFFER
+  int q = min(isize(v)-vshift, isize(t)-tshift);
+  vector<ct_vertex> tv(q);
+  for(int i=0; i<q; i++) {
+    tv[i].coords = v[vshift+i],
+    tv[i].texture[0] = t[tshift+i][0],
+    tv[i].texture[1] = t[tshift+i][1];
+    for(int i=0; i<SHDIM; i++)
+      tv[i].color[i] = c[tshift+i][i];
+    if(SHDIM == 3) tv[i].color[3] = 1;
+    }
+  prepare(tv);
+  #else
+  vertices(v, vshift);
+  WITHSHADER({
+    glVertexAttribPointer(aTexture, SHDIM, GL_FLOAT, GL_FALSE, sizeof(glvertex), &t[tshift]);
+    glVertexAttribPointer(aColor, 4, GL_FLOAT, GL_FALSE, sizeof(glvertex), &c[tshift]);
+    }, {
+    glTexCoordPointer(SHDIM, GL_FLOAT, 0, &t[tshift]);
+    glColorPointer(4, GL_FLOAT, sizeof(colored_vertex), &c[0]);
+    }
+    )
+  #endif
+  }
+
+EX void prepare(vector<colored_vertex>& v) {
+  #if CAP_VERTEXBUFFER
+  bindbuffer(v);
+  PTR(aPosition, SHDIM, coords);
+  PTR(aColor, 4, color);
+  #else
+  if(current_vertices == &v[0]) return;
+  current_vertices = &v[0];
+  WITHSHADER({
+    glVertexAttribPointer(aPosition, SHDIM, GL_FLOAT, GL_FALSE, sizeof(colored_vertex), &v[0].coords);
+    glVertexAttribPointer(aColor, 4, GL_FLOAT, GL_FALSE, sizeof(colored_vertex), &v[0].color);
+    }, {
+    glVertexPointer(SHDIM, GL_FLOAT, sizeof(colored_vertex), &v[0].coords);
+    glColorPointer(4, GL_FLOAT, sizeof(colored_vertex), &v[0].color);
+    })
+  #endif
+  }
+
+EX void prepare(vector<textured_vertex>& v) {
+  #if CAP_VERTEXBUFFER
+  bindbuffer(v);
+  PTR(aPosition, SHDIM, coords);
+  PTR(aTexture, 3, texture);
+  #else
+  if(current_vertices == &v[0]) return;
+  current_vertices = &v[0];
+  WITHSHADER({
+    glVertexAttribPointer(aPosition, SHDIM, GL_FLOAT, GL_FALSE, sizeof(textured_vertex), &v[0].coords);
+    glVertexAttribPointer(aTexture, SHDIM, GL_FLOAT, GL_FALSE, sizeof(textured_vertex), &v[0].texture);
+    }, {    
+    glVertexPointer(SHDIM, GL_FLOAT, sizeof(textured_vertex), &v[0].coords);
+    glTexCoordPointer(3, GL_FLOAT, sizeof(textured_vertex), &v[0].texture);
+    })
+  #endif
+  // color2(col);
+  }
+
+EX void prepare(vector<ct_vertex>& v) {
+  #if CAP_VERTEXBUFFER
+  bindbuffer(v);
+  PTR(aPosition, SHDIM, coords);
+  PTR(aColor, 4, color);
+  PTR(aTexture, 2, texture);
+  #else
+  if(current_vertices == &v[0]) return;
+  current_vertices = &v[0];
+  WITHSHADER({
+    glVertexAttribPointer(aPosition, SHDIM, GL_FLOAT, GL_FALSE, sizeof(ct_vertex), &v[0].coords);
+    glVertexAttribPointer(aColor, 4, GL_FLOAT, GL_FALSE, sizeof(ct_vertex), &v[0].color);
+    glVertexAttribPointer(aTexture, 2, GL_FLOAT, GL_FALSE, sizeof(ct_vertex), &v[0].texture);
+    }, {
+    glVertexPointer(SHDIM, GL_FLOAT, sizeof(ct_vertex), &v[0].coords);
+    glTexCoordPointer(2, GL_FLOAT, sizeof(ct_vertex), &v[0].texture);
+    glColorPointer(4, GL_FLOAT, sizeof(ct_vertex), &v[0].color);
+    })
+  #endif
+  }
+
+EX void store_in_buffer(vector<glvertex>& v) {
+#if CAP_VERTEXBUFFER
+  if(!buf_buffered) {
+    printf("no buffer yet\n");
+    return;
+    }
+  printf("storing %d in buffer: %p\n", isize(v), &v[0]);
+  current_vertices = buffered_vertices = &v[0];
+  glBindBuffer(GL_ARRAY_BUFFER, buf_buffered);
+  glVertexAttribPointer(aPosition, SHDIM, GL_FLOAT, GL_FALSE, sizeof(glvertex), 0);
+  glBufferData(GL_ARRAY_BUFFER, isize(v) * sizeof(glvertex), &v[0], GL_STATIC_DRAW);
+  printf("Stored.\n");
+#endif
+  }
+
+EX void set_depthtest(bool b) {
+  if(b != current_depthtest) {
+    current_depthtest = b;
+    if(b) glEnable(GL_DEPTH_TEST);
+    else glDisable(GL_DEPTH_TEST);
+    }
+  }
+
+
+EX void set_depthwrite(bool b) {
+  if(b != current_depthwrite) { // <- this does not work ask intended for some reason...
+    current_depthwrite = b;
+    if(b) glDepthMask(GL_TRUE);
+    else glDepthMask(GL_FALSE);
+    }
+  }
+
+EX void set_linewidth(ld lw) {
+  if(lw != current_linewidth) {
+    current_linewidth = lw;
+    glLineWidth(lw);
+    }
+  }
+
+EX void switch_to_text(const vector<glvertex>& v, const vector<glvertex>& t) {
+  current_display->next_shader_flags = GF_TEXTURE;
+  dynamicval<eModel> pm(pmodel, mdPixel);
+  if(!svg::in) current_display->set_all(0, 0);
+  vertices_texture(v, t, 0, 0);
+  }
+
+EX void be_nontextured() { current_display->next_shader_flags = 0; }
+EX void be_textured() { current_display->next_shader_flags = GF_TEXTURE; }
+EX void be_color_textured() { current_display->next_shader_flags = GF_TEXTURE | GF_VARCOLOR; }
+
+EX }
+
+EX vector<glhr::textured_vertex> text_vertices;
+
+EX void texture_vertices(GLfloat *f, int qty, int stride IS(2)) {
+  WITHSHADER(
+    glVertexAttribPointer(aTexture, stride, GL_FLOAT, GL_FALSE, stride * sizeof(GLfloat), f);,
+    glTexCoordPointer(stride, GL_FLOAT, 0, f);
+    )
+  } 
+
+EX void oldvertices(GLfloat *f, int qty) {
+  WITHSHADER(
+   glVertexAttribPointer(aPosition, SHDIM, GL_FLOAT, GL_FALSE, SHDIM * sizeof(GLfloat), f);,
+   glVertexPointer(SHDIM, GL_FLOAT, 0, f);
+   )
+  }
+
+#endif
+}
+
+#define glMatrixMode DISABLED
+#define glLoadIdentity DISABLED
+#define glMultMatrixf DISABLED
+#define glScalef DISABLED
+#define glTranslatef DISABLED
+#define glPushMatrix DISABLED
+#define glPopMatrix DISABLED
+

heptagon.cpp

@@ -1,9 +1,13 @@
-// Hyperbolic Rogue
+// Hyperbolic Rogue -- Heptagon
 // Copyright (C) 2011-2018 Zeno Rogue, see 'hyper.cpp' for details
 
-// heptagon here refers to underlying heptagonal tesselation
-// (which you can see by changing the conditions in graph.cpp)
+/** \file heptagon.cpp
+ *  \brief implementation of Heptagons
+ *
+ *  Start with locations.cpp
+ */
 
+#include "hyper.h"
 namespace hr {
 
 #define MIRR(x) x.mirrored
@@ -13,15 +17,15 @@ int heptacount = 0;
 struct cell;
 cell *newCell(int type, heptagon *master);
 
-// spintable functions
+/** the automaton is used to generate each heptagon in an unique way.
+ *  See http://roguetemple.com/z/dev.php for more help.
+ *  From the origin we can go further in any direction, and from other heptagons
+ *  we can go in directions 3 and 4 (0 is back to origin, so 3 and 4 go forward),
+ *  and sometimes in direction 5
+ */
 
-// the automaton is used to generate each heptagon in an unique way
-// (you can see the tree obtained by changing the conditions in graph.cpp)
-// from the origin we can go further in any direction, and from other heptagons
-// we can go in directions 3 and 4 (0 is back to origin, so 3 and 4 go forward),
-// and sometimes in direction 5
-
-hstate transition(hstate s, int dir) {
+EX hstate transition(hstate s, int dir) {
+  if(embedded_plane) return IPF(transition(s, dir));
   if(sphere) {
     if(S7 == 4) {
       if(s == hsOrigin) return dir == 0 ? hsB0 : hsB1;
@@ -49,6 +53,10 @@ hstate transition(hstate s, int dir) {
     if(s == hsB && (dir >= 2 && dir < S7-2)) return hsA;
     if(s == hsB && (dir == S7-2)) return hsB;
     }
+  else if(S3 >= OINF) {
+    if(s == hsOrigin) return hsA;
+    if(s == hsA && dir) return hsA;
+    }
   else {
     if(s == hsOrigin) return hsA;
     if(s == hsA && dir >= 3 && dir <= S7-3) return hsA;
@@ -62,27 +70,46 @@ hstate transition(hstate s, int dir) {
 #define COMPUTE -1000000
 
 // create a new heptagon
-heptagon *buildHeptagon1(heptagon *h, heptagon *parent, int d, hstate s, int pard = 0, int fixdistance = COMPUTE) {
+EX heptagon *buildHeptagon1(heptagon *h, heptagon *parent, int d, hstate s, int pard IS(0)) {
   h->alt = NULL;
   h->s = s;
   h->c.connect(pard, parent, d, false);
   h->cdata = NULL;
   return h;
   }
+
+EX heptagon *init_heptagon(int type) {
+  heptagon *h = tailored_alloc<heptagon> (type);
+  h->emeraldval = 0;
+  h->zebraval = 0;
+  h->fiftyval = 0;
+  h->fieldval = 0;
+  h->rval0 = h->rval1 = 0;
+  h->cdata = NULL;
+  h->alt = NULL;
+  h->c7 = NULL;
+  h->distance = 0;
+  h->dm4 = 0;
+  return h;
+  }
   
 heptagon *buildHeptagon(heptagon *parent, int d, hstate s, int pard = 0, int fixdistance = COMPUTE) {
-  heptagon *h = buildHeptagon1(tailored_alloc<heptagon> (S7), parent, d, s, pard, fixdistance);
-  if(binarytiling || archimedean) return h;
+  heptagon *h = buildHeptagon1(tailored_alloc<heptagon> (S7), parent, d, s, pard);
+  if(bt::in() || arcm::in()) return h;
   if(parent->c7) {
+    #if CAP_IRR
     if(IRREGULAR)
       irr::link_next(parent, d);
     else
+    #endif
       h->c7 = newCell(S7, h);
     h->rval0 = h->rval1 = 0;
     h->emeraldval = emerald_heptagon(parent->emeraldval, d);
     h->zebraval = zebra_heptagon(parent->zebraval, d);
+    #if CAP_FIELD
     if(&currfp != &fieldpattern::fp_invalid)
       h->fieldval = currfp.connections[fieldpattern::btspin(parent->fieldval, d)];
+    #endif
     if(a38) 
       h->fiftyval = fifty_38(parent->fiftyval, d);  
     else if(parent->s == hsOrigin)
@@ -108,9 +135,16 @@ heptagon *buildHeptagon(heptagon *parent, int d, hstate s, int pard = 0, int fix
       if(h->c.spin(0) == 2 && h->move(0)) {
         int d = h->c.spin(0);
         int d1 = (d+S7-1)%S7;
-        heptagon* h1 = createStep(h->move(0), d1);
-        if(h1->distance <= h->move(0)->distance)
-          h->distance = h->move(0)->distance+1;
+        bool missing0 = !h->move(0)->move(d1);
+        if(missing0) {
+          if(s == 1 && h->move(0)->s != hsOrigin)
+            h->distance = h->move(0)->distance + 1;
+          }
+        else {
+          heptagon* h1 = createStep(h->move(0), d1);
+          if(h1->distance <= h->move(0)->distance)
+            h->distance = h->move(0)->distance+1;
+          }
         }
       if((h->s == hsB && h->move(0)->s == hsB) || h->move(0)->s == hsA) {
         int d = h->c.spin(0);
@@ -118,13 +152,26 @@ heptagon *buildHeptagon(heptagon *parent, int d, hstate s, int pard = 0, int fix
         if(h1->distance <= h->move(0)->distance)
           h->distance = h->move(0)->distance+1;
         }
-      if(h->c.spin(0) == S7-1 && h->move(0)->distance != 0)
-        h->distance = min(
-          h->move(0)->move(0)->distance + 2,
-          createStep(h, S7-1)->distance + 1
-          );
+      if(h->c.spin(0) == S7-1 && (h->move(0)->s != hsOrigin) && BITRUNCATED) {
+        bool missing = !h->move(S7-1);
+        if(missing) {
+          h->distance = parent->distance;
+          if(
+            parent->distance - h->move(0)->move(0)->distance == 1 &&
+            h->c.spin(0) == S7 - 1 &&
+            h->move(0)->c.spin(0) == 2)
+            h->distance++;
+          }
+        else {
+          h->distance = min(
+            h->move(0)->move(0)->distance + 2,
+            createStep(h, S7-1)->distance + 1
+            );
+          }
+        }
       }
     else if(parent->s == hsOrigin) h->distance = parent->distance + gp::dist_2();
+    #if CAP_GP
     else if(S3 == 4 && GOLDBERG && h->c.spin(0) == S7-2 && h->move(0)->c.spin(0) >= S7-2 && h->move(0)->move(0)->s != hsOrigin) {
       heptspin hs(h, 0);
       hs += wstep;
@@ -133,7 +180,7 @@ heptagon *buildHeptagon(heptagon *parent, int d, hstate s, int pard = 0, int fix
       int dm = hs.at->distance;
       hs += -1; hs += wstep;
       int d0 = hs.at->distance;
-      h->distance = gp::solve_triangle(dm, d0, d1, gp::operator* (gp::param, gp::loc(-1,1)));
+      h->distance = gp::solve_triangle(dm, d0, d1, gp::param * gp::loc(-1,1));
       }
     else if(S3 == 4 && GOLDBERG && h->c.spin(0) == S7-1 && among(h->move(0)->c.spin(0), S7-2, S7-3) && h->move(0)->move(0)->s != hsOrigin) {
       heptspin hs(h, 0);
@@ -143,31 +190,33 @@ heptagon *buildHeptagon(heptagon *parent, int d, hstate s, int pard = 0, int fix
       int dm = hs.at->distance;
       hs += 1; hs += wstep;
       int d1 = hs.at->distance;
-      h->distance = gp::solve_triangle(dm, d0, d1, gp::operator* (gp::param, gp::loc(1,1)));
+      h->distance = gp::solve_triangle(dm, d0, d1, gp::param * gp::loc(1,1));
       }
     else if(S3 == 4 && GOLDBERG && h->c.spin(0) >= 2 && h->c.spin(0) <= S7-2) {
       h->distance = parent->distance + gp::dist_2();
       }
+    #endif
     else if(h->c.spin(0) == S7-2) {
-      if(!GOLDBERG)
-        h->distance = parent->distance + gp::dist_1();
-      else {
+      #if CAP_GP
+      if(GOLDBERG) {
         int d0 = parent->distance;
         int d1 = createStep(parent, S7-1)->distance;
         int dm = createStep(parent, 0)->distance;
-        h->distance = gp::solve_triangle(dm, d0, d1, gp::operator* (gp::param, gp::loc(1,1)));
-        }
+        h->distance = gp::solve_triangle(dm, d0, d1, gp::param * gp::loc(1,1));
+        } else
+      #endif
+      h->distance = parent->distance + gp::dist_1();
       }
     else if(h->c.spin(0) == S7-3 && h->move(0)->s == hsB) {
-      if(!GOLDBERG) {
-        h->distance = createStep(h->move(0), (h->c.spin(0)+2)%S7)->distance + gp::dist_3();
-        }
-      else {
+      #if CAP_GP
+      if(GOLDBERG) {
         int d0 = parent->distance;
         int d1 = createStep(parent, S7-2)->distance;
         int dm = createStep(parent, S7-1)->distance;
-        h->distance = gp::solve_triangle(dm, d0, d1, gp::operator* (gp::param, gp::loc(1,1)));
-        }
+        h->distance = gp::solve_triangle(dm, d0, d1, gp::param * gp::loc(1,1));
+        } else
+      #endif
+      h->distance = createStep(h->move(0), (h->c.spin(0)+2)%S7)->distance + gp::dist_3();
       }
     else if(h->c.spin(0) == S7-1 && S3 == 4 && GOLDBERG) {
       h->distance = parent->distance + gp::dist_1();
@@ -176,6 +225,9 @@ heptagon *buildHeptagon(heptagon *parent, int d, hstate s, int pard = 0, int fix
     }
   else {
     h->distance = parent->distance - gp::dist_2();
+    if(S3 == 4 && S7 > 5 && BITRUNCATED) {
+      h->distance = parent->distance - 2;
+      }
     if(S3 == 4 && S7 == 5) {
       if(h->s == hsOrigin) {
         printf("had to cheat!\n");
@@ -203,24 +255,18 @@ void addSpin(heptagon *h, int d, heptagon *from, int rot, int spin) {
 
 extern int hrand(int);
 
-// a structure used to walk on the heptagonal tesselation
-// (remembers not only the heptagon, but also direction)
-
-hookset<void(heptagon*, int)> *hooks_createStep;
+EX hookset<void(heptagon*, int)> hooks_createStep;
 
+// create h->move(d) if not created yet
 heptagon *createStep(heptagon *h, int d) {
   d = h->c.fix(d);
-  if(!h->move(d))
-    callhooks(hooks_createStep, h, d);
-  if(!h->move(d) && geometry == gCrystal) 
-    crystal::create_step(h, d);
-  if(!h->move(d) && binarytiling) 
-    return binary::createStep(h, d);
-  if(!h->move(d) && archimedean) {
-    arcm::create_adjacent(h, d); 
-    return h->move(d);
-    }
-  if(!h->move(0) && h->s != hsOrigin && !binarytiling && (geometry != gCrystal)) {
+  if(h->move(d)) return h->move(d);
+  callhooks(hooks_createStep, h, d);
+  return currentmap->create_step(h, d);
+  }
+
+heptagon *hrmap_standard::create_step(heptagon *h, int d) {
+  if(!h->move(0) && h->s != hsOrigin && !bt::in() && !cryst) {
     // cheating: 
     int pard=0;
     if(S3 == 3) 
@@ -229,7 +275,7 @@ heptagon *createStep(heptagon *h, int d) {
       pard = 3; // to do: randomize
     else if(S3 == 4)
       pard = 3;
-    buildHeptagon(h, 0, h->distance < -10000 ? hsOrigin : hsA, pard);
+    buildHeptagon(h, 0, h->distance < -global_distance_limit - 200 ? hsOrigin : hsA, pard);
     }
   if(h->move(d)) return h->move(d);
   if(h->s == hsOrigin) {
@@ -249,6 +295,12 @@ heptagon *createStep(heptagon *h, int d) {
     else 
       buildHeptagon(h, d, transition(h->s, d));
     }
+  else if(S3 > 4 && quotient) {
+    /* this branch may be used for some >4-valent quotient spaces outside of standard HyperRogue */
+    /* this is wrong, but we don't care in quotient */
+    h->move(d) = h;
+    // buildHeptagon(h, d, transition(h->s, d));
+    }
   else if(d == 1) {
     addSpin(h, d, h->move(0), h->c.spin(0)-1, -1);
     }
@@ -279,7 +331,4 @@ void hsshow(const heptspin& t) {
   printf("ORIGIN"); backtrace(t.at); printf(" (spin %d)\n", t.spin);
   }
 
-// create h->move(d) if not created yet
-heptagon *createStep(heptagon *h, int d);
-
 }

history.cpp

@@ -0,0 +1,777 @@
+// Hyperbolic Rogue -- the history mode
+// Copyright (C) 2011-2018 Zeno Rogue, see 'hyper.cpp' for details
+
+/** \file history.cpp
+ *  \brief Implementation of the history mode, including the long band and long spiral.
+ */
+
+#include "hyper.h"
+namespace hr {
+
+#if CAP_SDL
+namespace spiral {
+
+  typedef long double ld;
+  typedef complex<long double> cxld;
+
+  int shiftx, shifty, velx, vely;
+
+  vector<pair<short, short> > quickmap;
+
+  int CX, CY, SX, SY, Yshift;
+  
+  vector<SDL_Surface*> band;
+  SDL_Surface *out;
+  
+  bool displayhelp = true;
+  
+  color_t& bandpixel(int x, int y) {
+    int i = 0;
+    while(i < isize(band) && x >= band[i]->w)
+      x -= band[i]->w, i++;
+    return qpixel(band[i], x, y);
+    }
+  
+  void precompute() {
+  
+    CX = 0;
+    for(int i=0; i<isize(band); i++) CX += band[i]->w;
+    if(CX == 0) { printf("ERROR: no CX\n"); return; }
+    CY = band[0]->h;
+    SX = out->w;
+    SY = out->h;
+    
+    ld prec = 2*M_PI*M_PI;
+
+    ld k = -prec / log(2.6180339);
+
+    cxld factor = cxld(0, -CY/prec) * cxld(k, M_PI);
+    
+    Yshift = CY * k / M_PI;
+    
+    quickmap.clear();
+    
+    double xc = ((SX | 1) - 2) / 2.;
+    double yc = ((SY | 1) - 2) / 2.;
+    
+    for(int y=0; y<SY; y++)
+    for(int x=0; x<SX; x++) {
+      cxld z(x-xc, y-yc);
+      cxld z1 = log(z);
+
+      z1 = z1 * factor;
+
+      quickmap.push_back(make_pair(int(real(z1)) % CX, int(imag(z1))));
+      }
+    }
+  
+  void draw() {
+    int c = 0;
+    for(int y=0; y<SY; y++) for(int x=0; x<SX; x++) {
+      pair<short,short> p = quickmap[c++];
+      int cx = p.first + shiftx;
+      int cy = p.second + + shifty;
+      int d = cy / CY;
+      cy -= d * CY; cx -= d * Yshift;
+      if(cy<0) cy += CY, cx += Yshift;
+      cx %= CX; if(cx<0) cx += CX;
+      qpixel(out, x, y) = bandpixel(cx, cy);
+      }
+    }
+
+  void loop(vector<SDL_Surface*> _band) {
+
+    renderbuffer rb(vid.xres, vid.yres, false);
+
+    if(vid.usingGL) {
+      rb.make_surface();
+      out = rb.srf;
+      }
+    else
+      out = s;
+
+    band = _band;
+    precompute();
+    if(CX == 0) return;
+    shiftx = shifty = 0;
+    velx=1; vely=1;
+    bool dosave = false;
+    
+    while(true) {
+
+      time_t timer;
+      timer = time(NULL);
+      char buf[128]; 
+      strftime(buf, 128, "spiral-%y%m%d-%H%M%S" IMAGEEXT, localtime(&timer));
+
+      SDL_LockSurface(out);
+      draw();
+      if(vid.usingGL) {
+        calcparam();
+        setGLProjection();
+        current_display->next_shader_flags = GF_TEXTURE;
+        dynamicval<eModel> m(pmodel, mdPixel);
+        glhr::color2(0xFFFFFFFF);
+        glhr::set_depthtest(false);
+        glhr::current_vertices = NULL;
+        current_display->set_all(0,0);
+        vector<glhr::textured_vertex> rtver(4);
+        for(int i=0; i<4; i++) {
+          int cx[4] = {0, 1, 1, 0};
+          int cy[4] = {0, 0, 1, 1};
+          rtver[i].texture[0] = cx[i] * rb.x * 1. / rb.tx;
+          rtver[i].texture[1] = 1 - cy[i] * rb.y * 1. / rb.ty;
+          rtver[i].coords[0] = vid.xres * cx[i] - current_display->xcenter;
+          rtver[i].coords[1] = vid.yres * cy[i] - current_display->ycenter;
+          rtver[i].coords[2] = 0;
+          rtver[i].coords[3] = 1;
+          }
+        glhr::prepare(rtver);
+        rb.use_as_texture();
+        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+        }
+      if(dosave) { dosave = false; IMAGESAVE(out, buf); }
+      SDL_UnlockSurface(out);
+      if(displayhelp) {
+        displaystr(SX/2, vid.fsize*2, 0, vid.fsize, "arrows = navigate, ESC = return, h = hide help", forecolor, 8);
+        displaystr(SX/2, SY - vid.fsize*2, 0, vid.fsize, XLAT("s = save to " IMAGEEXT, buf), forecolor, 8);
+        glflush();
+        }
+      present_screen();
+      shiftx += velx; shifty += vely;
+
+      SDL_Event event;
+      while(SDL_PollEvent(&event)) switch (event.type) {
+
+        #if !CAP_SDL2
+        case SDL_VIDEORESIZE: {
+          resize_screen_to(event.resize.w, event.resize.h);
+          precompute();
+          break;
+          }
+        #endif
+        #if CAP_SDL2
+        case SDL_WINDOWEVENT: {
+          if(event.window.event == SDL_WINDOWEVENT_RESIZED)
+          resize_screen_to(event.window.data1, event.window.data2);
+          precompute();
+          break;
+          }
+        #endif
+        case SDL_QUIT: case SDL_MOUSEBUTTONDOWN:
+          goto breakloop;
+
+        case SDL_KEYDOWN: {
+          int sym = event.key.keysym.sym;
+          int uni = 0;
+          numlock_on = event.key.keysym.mod & KMOD_NUM;
+          if(DKEY == SDLK_RIGHT) velx++;
+          if(DKEY == SDLK_LEFT) velx--;
+          if(DKEY == SDLK_UP) vely++;
+          if(DKEY == SDLK_DOWN) vely--;
+          if(sym == SDLK_ESCAPE) goto breakloop;
+          if(sym == 'h') displayhelp = !displayhelp;
+          if(sym == 's') dosave = true;
+          }
+        }
+      }
+    
+    breakloop:
+    quickmap.clear();
+    }
+
+  }
+#endif
+
+EX namespace history {
+
+  void handleKeyC(int sym, int uni);
+  
+  int lastprogress;
+  
+  EX void progress_screen() {
+    gamescreen();
+    mouseovers = "";
+    }
+
+  EX int progress_each = 250;
+
+  EX void progress(string str) {
+#if CAP_SDL
+    int tick = SDL_GetTicks();
+    if(tick > lastprogress + progress_each) {
+      lastprogress = tick;
+      msgs.clear();
+      addMessage(str);
+      drawscreen();
+      }
+#endif
+    }
+  
+  EX bool on;
+  EX vector<shmup::monster*> v;
+  int llv;
+  EX double phase;
+  
+  EX vector<pair<cell*, eMonster> > killhistory;
+  EX vector<pair<cell*, eItem> > findhistory;
+  EX vector<cell*> movehistory;
+  
+  EX bool includeHistory;
+  EX ld lvspeed = 1;
+  EX int bandhalf = 200;
+  EX int bandsegment = 16000;
+  
+  EX int saved_ends;
+  
+  EX cell* first_center_at;
+  EX transmatrix first_center_view;
+  
+  EX void save_end() {
+    if(!allowIncreasedSight()) {
+      addMessage("Enable cheat mode or GAME OVER to use this");
+      return;
+      }
+    if(cheater) cheater++;
+    switch(saved_ends) {
+      case 0:
+        first_center_at = centerover;
+        first_center_view = View;
+        saved_ends = 1;
+        return;
+      
+      case 1: {
+        shmup::monster *m = new shmup::monster;
+        m->at = inverse(first_center_view);
+        m->base = first_center_at;
+        v.push_back(m);
+        create(first_center_at, centerover, inverse(unshift(ggmatrix(centerover))));
+        if(on) saved_ends = 2;
+        return;
+        }
+      
+      case 2:
+        on = false;
+        saved_ends = 0;
+        return;
+      }
+    }
+
+  EX bool autoband = false;
+  EX bool autobandhistory = false;
+  EX bool dospiral = true;
+  
+  EX ld extra_line_steps = 0;
+  
+  EX vector<cell*> path_for_lineanimation;
+
+  EX void clear() {
+    on = false;
+    int N = isize(v);
+    for(int i=0; i<N; i++) delete v[i];
+    v.resize(0);
+    }
+  
+  EX void smoothen_line() {
+    int Q = isize(v)-1;
+    // virtualRebase(v[0], false);
+    // virtualRebase(v[Q], false);
+    
+    for(int i=0; i<1000; i++) {
+      progress(XLAT("Preparing the line (%1/1000)...", its(i+1)));
+
+      for(int j=1; j<Q; j++) if((j^i)&1) {
+      
+        // virtualRebase(v[j], false);
+        
+        hyperpoint prev = calc_relative_matrix(v[j-1]->base, v[j]->base, C0) *
+          v[j-1]->at * C0;
+
+        hyperpoint next = calc_relative_matrix(v[j+1]->base, v[j]->base, C0) * 
+          v[j+1]->at * C0;
+        
+        hyperpoint hmid = mid(prev, next);
+        
+        transmatrix at = rgpushxto0(hmid);
+
+        v[j]->at = at * rspintox(inverse(at) * next);
+        fixmatrix(v[j]->at);
+        }
+      }
+    
+    hyperpoint next0 = calc_relative_matrix(v[1]->base, v[0]->base, C0) * v[1]->at * C0;
+    v[0]->at = v[0]->at * rspintox(inverse(v[0]->at) * next0);    
+    }
+
+  EX void create(cell *start, cell *target, transmatrix last) {
+    
+    if(target == start && !(quotient && isize(path_for_lineanimation) > 1)) {
+      addMessage("Must go a distance from the starting point");
+      return;
+      }
+    
+    on = true;
+  
+    if(!quotient && !arb::in()) try {
+      auto p = build_shortest_path(start, target);
+      path_for_lineanimation = p;
+      }
+    catch(const hr_shortest_path_exception&) {
+      addMessage("Could not build a path");
+      return;
+      }
+
+    for(cell *c: path_for_lineanimation) {
+      shmup::monster *m = new shmup::monster;
+      m->at = Id;
+      m->base = c;
+      v.push_back(m);
+      }
+    
+    v.back()->at = last;
+  
+    smoothen_line();
+  
+    llv = ticks;
+    phase = 0;
+    }
+
+  EX void create_playerpath() {
+    create(currentmap->gamestart(), cwt.at, Id);
+    }
+  
+  EX void create_recenter_to_view(bool precise) {
+    cell *c = centerover ? centerover : cwt.at;
+    create(path_for_lineanimation[0], c, precise ? inverse(unshift(ggmatrix(c))) : Id);
+    }
+  
+  EX void movetophase() {
+    
+    int ph = int(phase);
+    int siz = isize(v);
+    if(ph<0) ph = 0;
+    if(ph >= siz-1) ph = siz-2;
+    
+    cell *old = centerover;
+    
+    centerover = v[ph]->base;
+    
+    ld angle = 0;
+    if(WDIM == 3) {
+      hyperpoint h = inverse(models::rotmatrix()) * View * hpxy3(1,2,3);
+      angle = atan2(h[1], h[2]);
+      }
+    
+    View = inverse(v[ph]->at);
+    
+    if(arb::in() && v[ph]->base->master->emeraldval) View = Mirror * View;
+  
+    hyperpoint now = v[ph]->at * C0;
+
+    hyperpoint next = calc_relative_matrix(v[ph+1]->base, v[ph]->base, C0) * 
+      v[ph+1]->at * C0;
+  
+    View = xpush(-(phase-ph) * hdist(now, next)) * View;
+    if(WDIM == 2 || mproduct) {
+      View = models::rotmatrix() * View;
+      }
+    else {
+      if(celldistance(v[ph]->base, old) <= 2) {
+        hyperpoint h1 = View * currentmap->relative_matrix(old, centerover, C0) * hpxy3(1,2,3);
+        ld angle1 = atan2(h1[1], h1[2]);
+        View = cspin(2, 1, angle1 - angle) * View;
+        }
+      View = models::rotmatrix() * View;
+      }
+
+    playermoved = false;
+    centerover = v[ph]->base;
+    compute_graphical_distance();
+    }
+  
+  EX void apply() {
+    int t = ticks;
+    phase += (t-llv) * lvspeed / 400.;
+    llv = t;
+    
+    int siz = isize(v);
+    
+    while(phase > siz-1 + extra_line_steps) phase -= (siz + 2 * extra_line_steps-1);
+    while(phase < - extra_line_steps) phase += (siz + 2 * extra_line_steps-1);
+    
+    movetophase();
+    }
+  
+  ld measureLength() {
+    ld r = bandhalf * pconf.scale;
+    
+    ld tpixels = 0;
+    int siz = isize(v);
+
+    for(int j=0; j<siz-1; j++) {
+      hyperpoint next = 
+        inverse(v[j]->at) *
+        calc_relative_matrix(v[j+1]->base, v[j]->base, C0) * 
+        v[j+1]->at * C0;
+        
+      hyperpoint nextscr;
+      applymodel(shiftless(next), nextscr);
+      tpixels += nextscr[0] * r;
+      
+      if(j == 0 || j == siz-2)
+        tpixels += nextscr[0] * r * extra_line_steps;
+      }
+  
+    return tpixels;
+    }
+  
+  void restore();
+  void restoreBack();
+
+#if CAP_SHOT && CAP_SDL
+  string band_format_now = "bandmodel-$DATE-$ID" IMAGEEXT;
+  string band_format_auto = "bandmodel-$DATE-$ID" IMAGEEXT;
+#endif
+
+#if CAP_SDL
+  EX void createImage(const string& name_format, bool dospiral) {
+    int segid = 1;
+    if(includeHistory) restore();
+  
+    int bandfull = 2*bandhalf;
+    ld len = measureLength();
+    
+    time_t timer;
+    timer = time(NULL);
+    char timebuf[128]; 
+    strftime(timebuf, 128, "%y%m%d-%H%M%S", localtime(&timer));
+
+    vector<SDL_Surface*> bands;
+    
+    resetbuffer rbuf;
+    
+    if(1) {
+      // block for RAII
+      dynamicval<videopar> dv(vid, vid);
+      dynamicval<trans23> dr(models::rotation, Id);
+      dynamicval<bool> di(inHighQual, true);
+      
+      renderbuffer glbuf(bandfull, bandfull, vid.usingGL);
+      glbuf.make_surface(); if(!glbuf.srf) {
+        addMessage(XLAT("Could not create an image of that size."));
+        return;
+        }
+
+      vid.xres = vid.yres = bandfull;
+      glbuf.enable(); current_display->radius = bandhalf;  
+      calcparam();
+      
+      ld xpos = 0;
+      
+      int seglen = min(int(len), bandsegment);
+      
+      SDL_Surface *band = SDL_CreateRGBSurface(SDL_SWSURFACE, seglen, bandfull,32,0,0,0,0);
+      
+      auto save_band_segment = [&] {
+        string fname = name_format;
+        replace_str(fname, "$DATE", timebuf);
+        replace_str(fname, "$ID", hr::format("%03d", segid++));
+        IMAGESAVE(band, fname.c_str());
+
+        if(dospiral) 
+          bands.push_back(band);
+        else 
+          SDL_FreeSurface(band);
+        };
+      
+      if(!band) {
+        addMessage(XLAT("Could not create an image of that size."));
+        return;
+        }
+      else {
+  
+        int siz = isize(v);
+        
+        int bonus = ceil(extra_line_steps);
+  
+        cell *last_base = NULL;
+        hyperpoint last_relative;
+        
+        for(int j=-bonus; j<siz+bonus; j++) {
+          /*
+          SDL_Surface *buffer = s;
+          s = sav; 
+          
+          pushScreen(progress_screen);
+  
+          progress(s0 + hr::format("#%03d (%d/%d)", segid, j+bonus, siz+bonus+bonus-1)); */
+  
+          // calcparam(); current_display->radius = bandhalf;
+          phase = j; movetophase();
+      
+          glbuf.clear(backcolor);
+          drawfullmap();
+          
+          if(last_base) {
+            shiftpoint last = ggmatrix(last_base) * last_relative;
+            hyperpoint hscr;
+            applymodel(last, hscr);
+            ld bwidth = -current_display->radius * hscr[0];
+            println(hlog, "bwidth = ", bwidth, "/", len, " : ", xpos, "..", xpos+bwidth);
+            
+            drawsegment:
+            SDL_Surface *gr = glbuf.render();
+  
+            for(int cy=0; cy<bandfull; cy++) for(int cx=0; cx<=bwidth+3; cx++)
+              qpixel(band, int(xpos+cx), cy) = qpixel(gr, int(bandhalf+cx-bwidth), cy);
+            
+            if(j == 1-bonus)
+              xpos = bwidth * (extra_line_steps - bonus);
+        
+            if(xpos+bwidth > bandsegment) {
+              save_band_segment();    
+    
+              len -= bandsegment; xpos -= bandsegment;
+              seglen = min(int(len), bandsegment);
+              band = SDL_CreateRGBSurface(SDL_SWSURFACE, seglen, bandfull,32,0,0,0,0);
+              if(!band) {
+                addMessage(XLAT("Could not create an image of that size."));
+                return;
+                }
+              goto drawsegment;
+              }  
+            xpos += bwidth;      
+            }
+          
+          last_base = centerover;
+          last_relative = tC0(v[j]->at);
+          }
+        }
+
+      save_band_segment();
+      }
+
+    rbuf.reset();
+
+    if(includeHistory) restoreBack();
+    
+    if(dospiral) {
+      spiral::loop(bands);
+      for(int i=0; i<isize(bands); i++) SDL_FreeSurface(bands[i]);
+      }
+    }
+
+  EX void open_filedialog_to_create_image(bool ds) {
+    #if CAP_SHOT && CAP_SDL
+    dialog::openFileDialog(band_format_now, XLAT("rendered band ($ID=segment, $DATE=date)"), ".png", [ds] () {
+      createImage(band_format_now, ds);
+      return true;
+      });
+    #endif
+    }
+#endif
+
+  EX bool band_renderable_now() {
+    return on && (pmodel == mdBand || pmodel == mdBandEquidistant || pmodel == mdBandEquiarea) && !euclid && !sphere;
+    }
+  
+  EX void history_menu() {
+    cmode = sm::SIDE | sm::MAYDARK;
+    gamescreen();
+    
+    dialog::init(XLAT("history mode"));
+
+    dialog::addBoolItem(XLAT("include history"), (includeHistory), 'i');
+    
+    // bool notconformal0 = (pmodel >= 5 && pmodel <= 6) && !euclid;
+    // bool notconformal = notconformal0 || abs(pconf.alpha-1) > 1e-3;
+
+    dialog::addSelItem(XLAT("projection"), current_proj_name(), 'm');
+    
+    dialog::addBoolItem(XLAT("animate from start to current player position"), (on), 'e');
+    dialog::addBoolItem(XLAT("animate from last recenter to current view"), (on), 'E');
+    dialog::addBoolItem(XLAT("animate from last recenter to precise current view"), (on), 'E'-64);
+    
+    if(saved_ends == 0)
+      dialog::addItem(XLAT("save the animation starting point"), '1');
+    else if(saved_ends == 1)
+      dialog::addItem(XLAT("animate from the starting point"), '1');
+    else
+      dialog::addItem(XLAT("reset animation"), '1');
+    dialog::add_action(save_end);
+    
+    if(on) dialog::addSelItem(XLAT("animation speed"), fts(lvspeed), 'a');
+    else dialog::addBreak(100);
+    dialog::addSelItem(XLAT("extend the ends"), fts(extra_line_steps), 'p');
+    
+#if CAP_SDL
+    dialog::addBoolItem(XLAT("render bands automatically"), (autoband), 'o');
+    if(autoband)
+      dialog::addBoolItem(XLAT("include history when auto-rendering"), (autobandhistory), 'j');
+    
+    if(band_renderable_now() || autoband) {
+      dialog::addSelItem(XLAT("band width"), "2*"+its(bandhalf), 'd');
+      dialog::addSelItem(XLAT("length of a segment"), its(bandsegment), 's');
+      dialog::addBoolItem(XLAT("spiral on rendering"), (dospiral), 'g');
+      if(band_renderable_now())
+        dialog::addItem(XLAT("render now (length: %1)", fts(measureLength())), 'f');
+      }
+    else if(!on) ;
+    else if(!hyperbolic) 
+      dialog::addInfo(XLAT("more options in hyperbolic geometry"));
+    else if(!among(pmodel, mdBand, mdBandEquiarea, mdBandEquidistant))
+      dialog::addInfo(XLAT("more options in band projections"));
+    
+#endif
+      
+    dialog::addBack();
+    dialog::display();
+    mouseovers = XLAT("see http://www.roguetemple.com/z/hyper/models.php");
+    keyhandler = handleKeyC;
+    }
+
+  void handleKeyC(int sym, int uni) {
+    dialog::handleNavigation(sym, uni);
+  
+    if(uni == 'e' || uni == 'E' || uni == 'E'-64) {
+      if(on) clear();
+      else {
+        if(!allowIncreasedSight()) {
+          addMessage("Enable cheat mode or GAME OVER to use this");
+          return;
+          }
+        if(cheater) cheater++;
+        if(uni == 'E') create_recenter_to_view(false);
+        else if(uni == 'E'-64) create_recenter_to_view(true);
+        else create_playerpath();
+        }
+      }
+    else if(uni == 'o') {
+      autoband = !autoband;
+      #if CAP_SHOT && CAP_SDL
+      if(autoband)
+        dialog::openFileDialog(band_format_auto, XLAT("filename format to use ($ID=segment, $DATE=date)"), ".png", [] () { return true; });
+      #endif
+      }
+    else if(uni == 'm') 
+      pushScreen(models::model_menu);
+    else if(uni == 'a') 
+      dialog::editNumber(lvspeed, -5, 5, .1, 1, XLAT("animation speed"), "");
+    else if(uni == 'd') {
+      dialog::editNumber(bandhalf, 5, 1000, 5, 200, XLAT("band width"), "");
+      dialog::bound_low(5);
+      }
+    else if(uni == 's') {
+      dialog::editNumber(bandsegment, 500, 32000, 500, 16000, XLAT("band segment"), "");
+      dialog::bound_low(500);
+      }
+    else if(uni == 'p') 
+      dialog::editNumber(extra_line_steps, 0, 5, 1, 1, XLAT("extend the ends"), 
+        "0 = start at the game start, endat the end position; "
+        "larger numbers give extra space at the ends."
+        );
+    else if(uni == 'g') { dospiral = !dospiral; }
+    else if(uni == 'i') { 
+      if(!allowIncreasedSight()) {
+        addMessage("Enable cheat mode or GAME OVER to use this");
+        return;
+        }
+      if(cheater) cheater++;
+      includeHistory = !includeHistory; 
+      }
+#if CAP_SDL
+    else if(uni == 'f' && band_renderable_now()) 
+      open_filedialog_to_create_image(dospiral);
+    else if(uni == 'j') 
+      autobandhistory = !autobandhistory; 
+#endif
+    else if(doexiton(sym, uni)) popScreen();
+    }
+  
+  EX set<cell*> inmovehistory, inkillhistory, infindhistory;
+  
+  EX void restore() {
+    inmovehistory.clear();
+    inkillhistory.clear();
+    infindhistory.clear();
+    for(int i=0; i<isize(movehistory); i++)
+      inmovehistory.insert(movehistory[i]);
+    int sk = isize(killhistory);
+    for(int i=0; i<sk; i++) {
+      eMonster m = killhistory[i].second;
+      killhistory[i].second = killhistory[i].first->monst;
+      killhistory[i].first->monst = m;
+      inkillhistory.insert(killhistory[i].first);
+      }
+    int si = isize(findhistory);
+    for(int i=0; i<si; i++) {
+      eItem m = findhistory[i].second;
+      findhistory[i].second = findhistory[i].first->item;
+      findhistory[i].first->item = m;
+      infindhistory.insert(findhistory[i].first);
+      }
+    }
+
+  EX void restoreBack() {
+    int sk = isize(killhistory);
+    for(int i=sk-1; i>=0; i--) {
+      eMonster m = killhistory[i].second;
+      killhistory[i].second = killhistory[i].first->monst;
+      killhistory[i].first->monst = m;
+      }
+    int si = isize(findhistory);
+    for(int i=si-1; i>=0; i--) {
+      eItem m = findhistory[i].second;
+      findhistory[i].second = findhistory[i].first->item;
+      findhistory[i].first->item = m;
+      }
+    }
+  
+  EX void renderAutoband() {
+#if CAP_SDL && CAP_SHOT
+    if(!cwt.at || celldist(cwt.at) <= 7) return;
+    if(!autoband) return;
+    eModel spm = pmodel;
+    bool ih = includeHistory;
+    includeHistory = autobandhistory;
+    pmodel = mdBand;
+    create_playerpath();
+    createImage(band_format_auto, dospiral);
+    clear();
+    pmodel = spm;
+    includeHistory = ih;
+#endif
+    }
+
+  auto hookArg = arg::add3("-playerpath", history::create_playerpath);
+
+  auto hooks = addHook(hooks_clearmemory, 0, [] () {
+    history::renderAutoband();
+    history::on = false;
+    history::killhistory.clear();
+    history::findhistory.clear();
+    history::movehistory.clear();
+    history::path_for_lineanimation.clear();
+    history::saved_ends = 0;
+    history::includeHistory = false;
+    }) + addHook(hooks_configfile, 0, [] {
+
+    param_b(autobandhistory, "include history"); // check!
+    param_f(lvspeed, parameter_names("lvspeed", "lineview speed"));
+    param_f(extra_line_steps, "lineview extension");
+      
+    param_i(bandhalf, "band width");
+    param_i(bandsegment, "band segment");
+    param_b(autoband, "automatic band");
+    param_b(autobandhistory, "automatic band history");
+    param_b(dospiral, "do spiral");
+
+    #if CAP_SHOT && CAP_SDL
+    param_str(band_format_auto, "band_format_auto");
+    param_str(band_format_now, "band_format_now");
+    #endif
+    });
+
+  }
+
+}